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_ring.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 VkPhysicalDeviceMultiDrawFeaturesEXT chain */
2242
2243 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiDrawFeaturesEXT_pnext(const void * val)2244 vn_sizeof_VkPhysicalDeviceMultiDrawFeaturesEXT_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_VkPhysicalDeviceMultiDrawFeaturesEXT_self(const VkPhysicalDeviceMultiDrawFeaturesEXT * val)2251 vn_sizeof_VkPhysicalDeviceMultiDrawFeaturesEXT_self(const VkPhysicalDeviceMultiDrawFeaturesEXT *val)
2252 {
2253 size_t size = 0;
2254 /* skip val->{sType,pNext} */
2255 size += vn_sizeof_VkBool32(&val->multiDraw);
2256 return size;
2257 }
2258
2259 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiDrawFeaturesEXT(const VkPhysicalDeviceMultiDrawFeaturesEXT * val)2260 vn_sizeof_VkPhysicalDeviceMultiDrawFeaturesEXT(const VkPhysicalDeviceMultiDrawFeaturesEXT *val)
2261 {
2262 size_t size = 0;
2263
2264 size += vn_sizeof_VkStructureType(&val->sType);
2265 size += vn_sizeof_VkPhysicalDeviceMultiDrawFeaturesEXT_pnext(val->pNext);
2266 size += vn_sizeof_VkPhysicalDeviceMultiDrawFeaturesEXT_self(val);
2267
2268 return size;
2269 }
2270
2271 static inline void
vn_encode_VkPhysicalDeviceMultiDrawFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)2272 vn_encode_VkPhysicalDeviceMultiDrawFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
2273 {
2274 /* no known/supported struct */
2275 vn_encode_simple_pointer(enc, NULL);
2276 }
2277
2278 static inline void
vn_encode_VkPhysicalDeviceMultiDrawFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiDrawFeaturesEXT * val)2279 vn_encode_VkPhysicalDeviceMultiDrawFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiDrawFeaturesEXT *val)
2280 {
2281 /* skip val->{sType,pNext} */
2282 vn_encode_VkBool32(enc, &val->multiDraw);
2283 }
2284
2285 static inline void
vn_encode_VkPhysicalDeviceMultiDrawFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiDrawFeaturesEXT * val)2286 vn_encode_VkPhysicalDeviceMultiDrawFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiDrawFeaturesEXT *val)
2287 {
2288 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT);
2289 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT });
2290 vn_encode_VkPhysicalDeviceMultiDrawFeaturesEXT_pnext(enc, val->pNext);
2291 vn_encode_VkPhysicalDeviceMultiDrawFeaturesEXT_self(enc, val);
2292 }
2293
2294 static inline void
vn_decode_VkPhysicalDeviceMultiDrawFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)2295 vn_decode_VkPhysicalDeviceMultiDrawFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
2296 {
2297 /* no known/supported struct */
2298 if (vn_decode_simple_pointer(dec))
2299 assert(false);
2300 }
2301
2302 static inline void
vn_decode_VkPhysicalDeviceMultiDrawFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiDrawFeaturesEXT * val)2303 vn_decode_VkPhysicalDeviceMultiDrawFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiDrawFeaturesEXT *val)
2304 {
2305 /* skip val->{sType,pNext} */
2306 vn_decode_VkBool32(dec, &val->multiDraw);
2307 }
2308
2309 static inline void
vn_decode_VkPhysicalDeviceMultiDrawFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiDrawFeaturesEXT * val)2310 vn_decode_VkPhysicalDeviceMultiDrawFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiDrawFeaturesEXT *val)
2311 {
2312 VkStructureType stype;
2313 vn_decode_VkStructureType(dec, &stype);
2314 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT);
2315
2316 assert(val->sType == stype);
2317 vn_decode_VkPhysicalDeviceMultiDrawFeaturesEXT_pnext(dec, val->pNext);
2318 vn_decode_VkPhysicalDeviceMultiDrawFeaturesEXT_self(dec, val);
2319 }
2320
2321 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiDrawFeaturesEXT_pnext_partial(const void * val)2322 vn_sizeof_VkPhysicalDeviceMultiDrawFeaturesEXT_pnext_partial(const void *val)
2323 {
2324 /* no known/supported struct */
2325 return vn_sizeof_simple_pointer(NULL);
2326 }
2327
2328 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiDrawFeaturesEXT_self_partial(const VkPhysicalDeviceMultiDrawFeaturesEXT * val)2329 vn_sizeof_VkPhysicalDeviceMultiDrawFeaturesEXT_self_partial(const VkPhysicalDeviceMultiDrawFeaturesEXT *val)
2330 {
2331 size_t size = 0;
2332 /* skip val->{sType,pNext} */
2333 /* skip val->multiDraw */
2334 return size;
2335 }
2336
2337 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiDrawFeaturesEXT_partial(const VkPhysicalDeviceMultiDrawFeaturesEXT * val)2338 vn_sizeof_VkPhysicalDeviceMultiDrawFeaturesEXT_partial(const VkPhysicalDeviceMultiDrawFeaturesEXT *val)
2339 {
2340 size_t size = 0;
2341
2342 size += vn_sizeof_VkStructureType(&val->sType);
2343 size += vn_sizeof_VkPhysicalDeviceMultiDrawFeaturesEXT_pnext_partial(val->pNext);
2344 size += vn_sizeof_VkPhysicalDeviceMultiDrawFeaturesEXT_self_partial(val);
2345
2346 return size;
2347 }
2348
2349 static inline void
vn_encode_VkPhysicalDeviceMultiDrawFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)2350 vn_encode_VkPhysicalDeviceMultiDrawFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2351 {
2352 /* no known/supported struct */
2353 vn_encode_simple_pointer(enc, NULL);
2354 }
2355
2356 static inline void
vn_encode_VkPhysicalDeviceMultiDrawFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiDrawFeaturesEXT * val)2357 vn_encode_VkPhysicalDeviceMultiDrawFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiDrawFeaturesEXT *val)
2358 {
2359 /* skip val->{sType,pNext} */
2360 /* skip val->multiDraw */
2361 }
2362
2363 static inline void
vn_encode_VkPhysicalDeviceMultiDrawFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiDrawFeaturesEXT * val)2364 vn_encode_VkPhysicalDeviceMultiDrawFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiDrawFeaturesEXT *val)
2365 {
2366 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT);
2367 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT });
2368 vn_encode_VkPhysicalDeviceMultiDrawFeaturesEXT_pnext_partial(enc, val->pNext);
2369 vn_encode_VkPhysicalDeviceMultiDrawFeaturesEXT_self_partial(enc, val);
2370 }
2371
2372 /* struct VkPhysicalDeviceInlineUniformBlockFeatures chain */
2373
2374 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(const void * val)2375 vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(const void *val)
2376 {
2377 /* no known/supported struct */
2378 return vn_sizeof_simple_pointer(NULL);
2379 }
2380
2381 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self(const VkPhysicalDeviceInlineUniformBlockFeatures * val)2382 vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self(const VkPhysicalDeviceInlineUniformBlockFeatures *val)
2383 {
2384 size_t size = 0;
2385 /* skip val->{sType,pNext} */
2386 size += vn_sizeof_VkBool32(&val->inlineUniformBlock);
2387 size += vn_sizeof_VkBool32(&val->descriptorBindingInlineUniformBlockUpdateAfterBind);
2388 return size;
2389 }
2390
2391 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures(const VkPhysicalDeviceInlineUniformBlockFeatures * val)2392 vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures(const VkPhysicalDeviceInlineUniformBlockFeatures *val)
2393 {
2394 size_t size = 0;
2395
2396 size += vn_sizeof_VkStructureType(&val->sType);
2397 size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(val->pNext);
2398 size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self(val);
2399
2400 return size;
2401 }
2402
2403 static inline void
vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2404 vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2405 {
2406 /* no known/supported struct */
2407 vn_encode_simple_pointer(enc, NULL);
2408 }
2409
2410 static inline void
vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceInlineUniformBlockFeatures * val)2411 vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceInlineUniformBlockFeatures *val)
2412 {
2413 /* skip val->{sType,pNext} */
2414 vn_encode_VkBool32(enc, &val->inlineUniformBlock);
2415 vn_encode_VkBool32(enc, &val->descriptorBindingInlineUniformBlockUpdateAfterBind);
2416 }
2417
2418 static inline void
vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceInlineUniformBlockFeatures * val)2419 vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceInlineUniformBlockFeatures *val)
2420 {
2421 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES);
2422 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES });
2423 vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(enc, val->pNext);
2424 vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self(enc, val);
2425 }
2426
2427 static inline void
vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(struct vn_cs_decoder * dec,const void * val)2428 vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
2429 {
2430 /* no known/supported struct */
2431 if (vn_decode_simple_pointer(dec))
2432 assert(false);
2433 }
2434
2435 static inline void
vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceInlineUniformBlockFeatures * val)2436 vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceInlineUniformBlockFeatures *val)
2437 {
2438 /* skip val->{sType,pNext} */
2439 vn_decode_VkBool32(dec, &val->inlineUniformBlock);
2440 vn_decode_VkBool32(dec, &val->descriptorBindingInlineUniformBlockUpdateAfterBind);
2441 }
2442
2443 static inline void
vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceInlineUniformBlockFeatures * val)2444 vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceInlineUniformBlockFeatures *val)
2445 {
2446 VkStructureType stype;
2447 vn_decode_VkStructureType(dec, &stype);
2448 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES);
2449
2450 assert(val->sType == stype);
2451 vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(dec, val->pNext);
2452 vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures_self(dec, val);
2453 }
2454
2455 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_pnext_partial(const void * val)2456 vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_pnext_partial(const void *val)
2457 {
2458 /* no known/supported struct */
2459 return vn_sizeof_simple_pointer(NULL);
2460 }
2461
2462 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial(const VkPhysicalDeviceInlineUniformBlockFeatures * val)2463 vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial(const VkPhysicalDeviceInlineUniformBlockFeatures *val)
2464 {
2465 size_t size = 0;
2466 /* skip val->{sType,pNext} */
2467 /* skip val->inlineUniformBlock */
2468 /* skip val->descriptorBindingInlineUniformBlockUpdateAfterBind */
2469 return size;
2470 }
2471
2472 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_partial(const VkPhysicalDeviceInlineUniformBlockFeatures * val)2473 vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_partial(const VkPhysicalDeviceInlineUniformBlockFeatures *val)
2474 {
2475 size_t size = 0;
2476
2477 size += vn_sizeof_VkStructureType(&val->sType);
2478 size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_pnext_partial(val->pNext);
2479 size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial(val);
2480
2481 return size;
2482 }
2483
2484 static inline void
vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)2485 vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2486 {
2487 /* no known/supported struct */
2488 vn_encode_simple_pointer(enc, NULL);
2489 }
2490
2491 static inline void
vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceInlineUniformBlockFeatures * val)2492 vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceInlineUniformBlockFeatures *val)
2493 {
2494 /* skip val->{sType,pNext} */
2495 /* skip val->inlineUniformBlock */
2496 /* skip val->descriptorBindingInlineUniformBlockUpdateAfterBind */
2497 }
2498
2499 static inline void
vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceInlineUniformBlockFeatures * val)2500 vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceInlineUniformBlockFeatures *val)
2501 {
2502 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES);
2503 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES });
2504 vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext_partial(enc, val->pNext);
2505 vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial(enc, val);
2506 }
2507
2508 /* struct VkPhysicalDeviceMaintenance4Features chain */
2509
2510 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Features_pnext(const void * val)2511 vn_sizeof_VkPhysicalDeviceMaintenance4Features_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_VkPhysicalDeviceMaintenance4Features_self(const VkPhysicalDeviceMaintenance4Features * val)2518 vn_sizeof_VkPhysicalDeviceMaintenance4Features_self(const VkPhysicalDeviceMaintenance4Features *val)
2519 {
2520 size_t size = 0;
2521 /* skip val->{sType,pNext} */
2522 size += vn_sizeof_VkBool32(&val->maintenance4);
2523 return size;
2524 }
2525
2526 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Features(const VkPhysicalDeviceMaintenance4Features * val)2527 vn_sizeof_VkPhysicalDeviceMaintenance4Features(const VkPhysicalDeviceMaintenance4Features *val)
2528 {
2529 size_t size = 0;
2530
2531 size += vn_sizeof_VkStructureType(&val->sType);
2532 size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_pnext(val->pNext);
2533 size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_self(val);
2534
2535 return size;
2536 }
2537
2538 static inline void
vn_encode_VkPhysicalDeviceMaintenance4Features_pnext(struct vn_cs_encoder * enc,const void * val)2539 vn_encode_VkPhysicalDeviceMaintenance4Features_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_VkPhysicalDeviceMaintenance4Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance4Features * val)2546 vn_encode_VkPhysicalDeviceMaintenance4Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance4Features *val)
2547 {
2548 /* skip val->{sType,pNext} */
2549 vn_encode_VkBool32(enc, &val->maintenance4);
2550 }
2551
2552 static inline void
vn_encode_VkPhysicalDeviceMaintenance4Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance4Features * val)2553 vn_encode_VkPhysicalDeviceMaintenance4Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance4Features *val)
2554 {
2555 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES);
2556 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES });
2557 vn_encode_VkPhysicalDeviceMaintenance4Features_pnext(enc, val->pNext);
2558 vn_encode_VkPhysicalDeviceMaintenance4Features_self(enc, val);
2559 }
2560
2561 static inline void
vn_decode_VkPhysicalDeviceMaintenance4Features_pnext(struct vn_cs_decoder * dec,const void * val)2562 vn_decode_VkPhysicalDeviceMaintenance4Features_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_VkPhysicalDeviceMaintenance4Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance4Features * val)2570 vn_decode_VkPhysicalDeviceMaintenance4Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance4Features *val)
2571 {
2572 /* skip val->{sType,pNext} */
2573 vn_decode_VkBool32(dec, &val->maintenance4);
2574 }
2575
2576 static inline void
vn_decode_VkPhysicalDeviceMaintenance4Features(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance4Features * val)2577 vn_decode_VkPhysicalDeviceMaintenance4Features(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance4Features *val)
2578 {
2579 VkStructureType stype;
2580 vn_decode_VkStructureType(dec, &stype);
2581 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES);
2582
2583 assert(val->sType == stype);
2584 vn_decode_VkPhysicalDeviceMaintenance4Features_pnext(dec, val->pNext);
2585 vn_decode_VkPhysicalDeviceMaintenance4Features_self(dec, val);
2586 }
2587
2588 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Features_pnext_partial(const void * val)2589 vn_sizeof_VkPhysicalDeviceMaintenance4Features_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_VkPhysicalDeviceMaintenance4Features_self_partial(const VkPhysicalDeviceMaintenance4Features * val)2596 vn_sizeof_VkPhysicalDeviceMaintenance4Features_self_partial(const VkPhysicalDeviceMaintenance4Features *val)
2597 {
2598 size_t size = 0;
2599 /* skip val->{sType,pNext} */
2600 /* skip val->maintenance4 */
2601 return size;
2602 }
2603
2604 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Features_partial(const VkPhysicalDeviceMaintenance4Features * val)2605 vn_sizeof_VkPhysicalDeviceMaintenance4Features_partial(const VkPhysicalDeviceMaintenance4Features *val)
2606 {
2607 size_t size = 0;
2608
2609 size += vn_sizeof_VkStructureType(&val->sType);
2610 size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_pnext_partial(val->pNext);
2611 size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_self_partial(val);
2612
2613 return size;
2614 }
2615
2616 static inline void
vn_encode_VkPhysicalDeviceMaintenance4Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)2617 vn_encode_VkPhysicalDeviceMaintenance4Features_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_VkPhysicalDeviceMaintenance4Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance4Features * val)2624 vn_encode_VkPhysicalDeviceMaintenance4Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance4Features *val)
2625 {
2626 /* skip val->{sType,pNext} */
2627 /* skip val->maintenance4 */
2628 }
2629
2630 static inline void
vn_encode_VkPhysicalDeviceMaintenance4Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance4Features * val)2631 vn_encode_VkPhysicalDeviceMaintenance4Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance4Features *val)
2632 {
2633 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES);
2634 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES });
2635 vn_encode_VkPhysicalDeviceMaintenance4Features_pnext_partial(enc, val->pNext);
2636 vn_encode_VkPhysicalDeviceMaintenance4Features_self_partial(enc, val);
2637 }
2638
2639 /* struct VkPhysicalDeviceMaintenance5FeaturesKHR chain */
2640
2641 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext(const void * val)2642 vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_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_VkPhysicalDeviceMaintenance5FeaturesKHR_self(const VkPhysicalDeviceMaintenance5FeaturesKHR * val)2649 vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_self(const VkPhysicalDeviceMaintenance5FeaturesKHR *val)
2650 {
2651 size_t size = 0;
2652 /* skip val->{sType,pNext} */
2653 size += vn_sizeof_VkBool32(&val->maintenance5);
2654 return size;
2655 }
2656
2657 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR(const VkPhysicalDeviceMaintenance5FeaturesKHR * val)2658 vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR(const VkPhysicalDeviceMaintenance5FeaturesKHR *val)
2659 {
2660 size_t size = 0;
2661
2662 size += vn_sizeof_VkStructureType(&val->sType);
2663 size += vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext(val->pNext);
2664 size += vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_self(val);
2665
2666 return size;
2667 }
2668
2669 static inline void
vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext(struct vn_cs_encoder * enc,const void * val)2670 vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext(struct vn_cs_encoder *enc, const void *val)
2671 {
2672 /* no known/supported struct */
2673 vn_encode_simple_pointer(enc, NULL);
2674 }
2675
2676 static inline void
vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance5FeaturesKHR * val)2677 vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance5FeaturesKHR *val)
2678 {
2679 /* skip val->{sType,pNext} */
2680 vn_encode_VkBool32(enc, &val->maintenance5);
2681 }
2682
2683 static inline void
vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance5FeaturesKHR * val)2684 vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance5FeaturesKHR *val)
2685 {
2686 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR);
2687 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR });
2688 vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext(enc, val->pNext);
2689 vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_self(enc, val);
2690 }
2691
2692 static inline void
vn_decode_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext(struct vn_cs_decoder * dec,const void * val)2693 vn_decode_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext(struct vn_cs_decoder *dec, const void *val)
2694 {
2695 /* no known/supported struct */
2696 if (vn_decode_simple_pointer(dec))
2697 assert(false);
2698 }
2699
2700 static inline void
vn_decode_VkPhysicalDeviceMaintenance5FeaturesKHR_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance5FeaturesKHR * val)2701 vn_decode_VkPhysicalDeviceMaintenance5FeaturesKHR_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance5FeaturesKHR *val)
2702 {
2703 /* skip val->{sType,pNext} */
2704 vn_decode_VkBool32(dec, &val->maintenance5);
2705 }
2706
2707 static inline void
vn_decode_VkPhysicalDeviceMaintenance5FeaturesKHR(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance5FeaturesKHR * val)2708 vn_decode_VkPhysicalDeviceMaintenance5FeaturesKHR(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance5FeaturesKHR *val)
2709 {
2710 VkStructureType stype;
2711 vn_decode_VkStructureType(dec, &stype);
2712 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR);
2713
2714 assert(val->sType == stype);
2715 vn_decode_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext(dec, val->pNext);
2716 vn_decode_VkPhysicalDeviceMaintenance5FeaturesKHR_self(dec, val);
2717 }
2718
2719 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext_partial(const void * val)2720 vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext_partial(const void *val)
2721 {
2722 /* no known/supported struct */
2723 return vn_sizeof_simple_pointer(NULL);
2724 }
2725
2726 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_self_partial(const VkPhysicalDeviceMaintenance5FeaturesKHR * val)2727 vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_self_partial(const VkPhysicalDeviceMaintenance5FeaturesKHR *val)
2728 {
2729 size_t size = 0;
2730 /* skip val->{sType,pNext} */
2731 /* skip val->maintenance5 */
2732 return size;
2733 }
2734
2735 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_partial(const VkPhysicalDeviceMaintenance5FeaturesKHR * val)2736 vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_partial(const VkPhysicalDeviceMaintenance5FeaturesKHR *val)
2737 {
2738 size_t size = 0;
2739
2740 size += vn_sizeof_VkStructureType(&val->sType);
2741 size += vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext_partial(val->pNext);
2742 size += vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_self_partial(val);
2743
2744 return size;
2745 }
2746
2747 static inline void
vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext_partial(struct vn_cs_encoder * enc,const void * val)2748 vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2749 {
2750 /* no known/supported struct */
2751 vn_encode_simple_pointer(enc, NULL);
2752 }
2753
2754 static inline void
vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance5FeaturesKHR * val)2755 vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance5FeaturesKHR *val)
2756 {
2757 /* skip val->{sType,pNext} */
2758 /* skip val->maintenance5 */
2759 }
2760
2761 static inline void
vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance5FeaturesKHR * val)2762 vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance5FeaturesKHR *val)
2763 {
2764 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR);
2765 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR });
2766 vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext_partial(enc, val->pNext);
2767 vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_self_partial(enc, val);
2768 }
2769
2770 /* struct VkPhysicalDeviceShaderDrawParametersFeatures chain */
2771
2772 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(const void * val)2773 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(const void *val)
2774 {
2775 /* no known/supported struct */
2776 return vn_sizeof_simple_pointer(NULL);
2777 }
2778
2779 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self(const VkPhysicalDeviceShaderDrawParametersFeatures * val)2780 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2781 {
2782 size_t size = 0;
2783 /* skip val->{sType,pNext} */
2784 size += vn_sizeof_VkBool32(&val->shaderDrawParameters);
2785 return size;
2786 }
2787
2788 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures * val)2789 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2790 {
2791 size_t size = 0;
2792
2793 size += vn_sizeof_VkStructureType(&val->sType);
2794 size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(val->pNext);
2795 size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self(val);
2796
2797 return size;
2798 }
2799
2800 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2801 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2802 {
2803 /* no known/supported struct */
2804 vn_encode_simple_pointer(enc, NULL);
2805 }
2806
2807 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDrawParametersFeatures * val)2808 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2809 {
2810 /* skip val->{sType,pNext} */
2811 vn_encode_VkBool32(enc, &val->shaderDrawParameters);
2812 }
2813
2814 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDrawParametersFeatures * val)2815 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2816 {
2817 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
2818 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES });
2819 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(enc, val->pNext);
2820 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, val);
2821 }
2822
2823 static inline void
vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_decoder * dec,const void * val)2824 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
2825 {
2826 /* no known/supported struct */
2827 if (vn_decode_simple_pointer(dec))
2828 assert(false);
2829 }
2830
2831 static inline void
vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderDrawParametersFeatures * val)2832 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDrawParametersFeatures *val)
2833 {
2834 /* skip val->{sType,pNext} */
2835 vn_decode_VkBool32(dec, &val->shaderDrawParameters);
2836 }
2837
2838 static inline void
vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderDrawParametersFeatures * val)2839 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDrawParametersFeatures *val)
2840 {
2841 VkStructureType stype;
2842 vn_decode_VkStructureType(dec, &stype);
2843 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
2844
2845 assert(val->sType == stype);
2846 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(dec, val->pNext);
2847 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(dec, val);
2848 }
2849
2850 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(const void * val)2851 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(const void *val)
2852 {
2853 /* no known/supported struct */
2854 return vn_sizeof_simple_pointer(NULL);
2855 }
2856
2857 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(const VkPhysicalDeviceShaderDrawParametersFeatures * val)2858 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2859 {
2860 size_t size = 0;
2861 /* skip val->{sType,pNext} */
2862 /* skip val->shaderDrawParameters */
2863 return size;
2864 }
2865
2866 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_partial(const VkPhysicalDeviceShaderDrawParametersFeatures * val)2867 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_partial(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2868 {
2869 size_t size = 0;
2870
2871 size += vn_sizeof_VkStructureType(&val->sType);
2872 size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(val->pNext);
2873 size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(val);
2874
2875 return size;
2876 }
2877
2878 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)2879 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2880 {
2881 /* no known/supported struct */
2882 vn_encode_simple_pointer(enc, NULL);
2883 }
2884
2885 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDrawParametersFeatures * val)2886 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2887 {
2888 /* skip val->{sType,pNext} */
2889 /* skip val->shaderDrawParameters */
2890 }
2891
2892 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDrawParametersFeatures * val)2893 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2894 {
2895 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
2896 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES });
2897 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(enc, val->pNext);
2898 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(enc, val);
2899 }
2900
2901 /* struct VkPhysicalDeviceShaderFloat16Int8Features chain */
2902
2903 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext(const void * val)2904 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext(const void *val)
2905 {
2906 /* no known/supported struct */
2907 return vn_sizeof_simple_pointer(NULL);
2908 }
2909
2910 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self(const VkPhysicalDeviceShaderFloat16Int8Features * val)2911 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self(const VkPhysicalDeviceShaderFloat16Int8Features *val)
2912 {
2913 size_t size = 0;
2914 /* skip val->{sType,pNext} */
2915 size += vn_sizeof_VkBool32(&val->shaderFloat16);
2916 size += vn_sizeof_VkBool32(&val->shaderInt8);
2917 return size;
2918 }
2919
2920 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features * val)2921 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features *val)
2922 {
2923 size_t size = 0;
2924
2925 size += vn_sizeof_VkStructureType(&val->sType);
2926 size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext(val->pNext);
2927 size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self(val);
2928
2929 return size;
2930 }
2931
2932 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_encoder * enc,const void * val)2933 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_encoder *enc, const void *val)
2934 {
2935 /* no known/supported struct */
2936 vn_encode_simple_pointer(enc, NULL);
2937 }
2938
2939 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderFloat16Int8Features * val)2940 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
2941 {
2942 /* skip val->{sType,pNext} */
2943 vn_encode_VkBool32(enc, &val->shaderFloat16);
2944 vn_encode_VkBool32(enc, &val->shaderInt8);
2945 }
2946
2947 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderFloat16Int8Features * val)2948 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
2949 {
2950 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
2951 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES });
2952 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(enc, val->pNext);
2953 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, val);
2954 }
2955
2956 static inline void
vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_decoder * dec,const void * val)2957 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_decoder *dec, const void *val)
2958 {
2959 /* no known/supported struct */
2960 if (vn_decode_simple_pointer(dec))
2961 assert(false);
2962 }
2963
2964 static inline void
vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderFloat16Int8Features * val)2965 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderFloat16Int8Features *val)
2966 {
2967 /* skip val->{sType,pNext} */
2968 vn_decode_VkBool32(dec, &val->shaderFloat16);
2969 vn_decode_VkBool32(dec, &val->shaderInt8);
2970 }
2971
2972 static inline void
vn_decode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderFloat16Int8Features * val)2973 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderFloat16Int8Features *val)
2974 {
2975 VkStructureType stype;
2976 vn_decode_VkStructureType(dec, &stype);
2977 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
2978
2979 assert(val->sType == stype);
2980 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(dec, val->pNext);
2981 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(dec, val);
2982 }
2983
2984 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(const void * val)2985 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(const void *val)
2986 {
2987 /* no known/supported struct */
2988 return vn_sizeof_simple_pointer(NULL);
2989 }
2990
2991 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(const VkPhysicalDeviceShaderFloat16Int8Features * val)2992 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(const VkPhysicalDeviceShaderFloat16Int8Features *val)
2993 {
2994 size_t size = 0;
2995 /* skip val->{sType,pNext} */
2996 /* skip val->shaderFloat16 */
2997 /* skip val->shaderInt8 */
2998 return size;
2999 }
3000
3001 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_partial(const VkPhysicalDeviceShaderFloat16Int8Features * val)3002 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_partial(const VkPhysicalDeviceShaderFloat16Int8Features *val)
3003 {
3004 size_t size = 0;
3005
3006 size += vn_sizeof_VkStructureType(&val->sType);
3007 size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(val->pNext);
3008 size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(val);
3009
3010 return size;
3011 }
3012
3013 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)3014 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3015 {
3016 /* no known/supported struct */
3017 vn_encode_simple_pointer(enc, NULL);
3018 }
3019
3020 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderFloat16Int8Features * val)3021 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
3022 {
3023 /* skip val->{sType,pNext} */
3024 /* skip val->shaderFloat16 */
3025 /* skip val->shaderInt8 */
3026 }
3027
3028 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderFloat16Int8Features * val)3029 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
3030 {
3031 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
3032 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES });
3033 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(enc, val->pNext);
3034 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(enc, val);
3035 }
3036
3037 /* struct VkPhysicalDeviceHostQueryResetFeatures chain */
3038
3039 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext(const void * val)3040 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext(const void *val)
3041 {
3042 /* no known/supported struct */
3043 return vn_sizeof_simple_pointer(NULL);
3044 }
3045
3046 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self(const VkPhysicalDeviceHostQueryResetFeatures * val)3047 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self(const VkPhysicalDeviceHostQueryResetFeatures *val)
3048 {
3049 size_t size = 0;
3050 /* skip val->{sType,pNext} */
3051 size += vn_sizeof_VkBool32(&val->hostQueryReset);
3052 return size;
3053 }
3054
3055 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures * val)3056 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures *val)
3057 {
3058 size_t size = 0;
3059
3060 size += vn_sizeof_VkStructureType(&val->sType);
3061 size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext(val->pNext);
3062 size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self(val);
3063
3064 return size;
3065 }
3066
3067 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_encoder * enc,const void * val)3068 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
3069 {
3070 /* no known/supported struct */
3071 vn_encode_simple_pointer(enc, NULL);
3072 }
3073
3074 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceHostQueryResetFeatures * val)3075 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
3076 {
3077 /* skip val->{sType,pNext} */
3078 vn_encode_VkBool32(enc, &val->hostQueryReset);
3079 }
3080
3081 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceHostQueryResetFeatures * val)3082 vn_encode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
3083 {
3084 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
3085 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES });
3086 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(enc, val->pNext);
3087 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, val);
3088 }
3089
3090 static inline void
vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3091 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3092 {
3093 /* no known/supported struct */
3094 if (vn_decode_simple_pointer(dec))
3095 assert(false);
3096 }
3097
3098 static inline void
vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceHostQueryResetFeatures * val)3099 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceHostQueryResetFeatures *val)
3100 {
3101 /* skip val->{sType,pNext} */
3102 vn_decode_VkBool32(dec, &val->hostQueryReset);
3103 }
3104
3105 static inline void
vn_decode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceHostQueryResetFeatures * val)3106 vn_decode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceHostQueryResetFeatures *val)
3107 {
3108 VkStructureType stype;
3109 vn_decode_VkStructureType(dec, &stype);
3110 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
3111
3112 assert(val->sType == stype);
3113 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext(dec, val->pNext);
3114 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(dec, val);
3115 }
3116
3117 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(const void * val)3118 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(const void *val)
3119 {
3120 /* no known/supported struct */
3121 return vn_sizeof_simple_pointer(NULL);
3122 }
3123
3124 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial(const VkPhysicalDeviceHostQueryResetFeatures * val)3125 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial(const VkPhysicalDeviceHostQueryResetFeatures *val)
3126 {
3127 size_t size = 0;
3128 /* skip val->{sType,pNext} */
3129 /* skip val->hostQueryReset */
3130 return size;
3131 }
3132
3133 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_partial(const VkPhysicalDeviceHostQueryResetFeatures * val)3134 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_partial(const VkPhysicalDeviceHostQueryResetFeatures *val)
3135 {
3136 size_t size = 0;
3137
3138 size += vn_sizeof_VkStructureType(&val->sType);
3139 size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(val->pNext);
3140 size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial(val);
3141
3142 return size;
3143 }
3144
3145 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)3146 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3147 {
3148 /* no known/supported struct */
3149 vn_encode_simple_pointer(enc, NULL);
3150 }
3151
3152 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceHostQueryResetFeatures * val)3153 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
3154 {
3155 /* skip val->{sType,pNext} */
3156 /* skip val->hostQueryReset */
3157 }
3158
3159 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceHostQueryResetFeatures * val)3160 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
3161 {
3162 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
3163 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES });
3164 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(enc, val->pNext);
3165 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(enc, val);
3166 }
3167
3168 /* struct VkPhysicalDeviceDescriptorIndexingFeatures chain */
3169
3170 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(const void * val)3171 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(const void *val)
3172 {
3173 /* no known/supported struct */
3174 return vn_sizeof_simple_pointer(NULL);
3175 }
3176
3177 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self(const VkPhysicalDeviceDescriptorIndexingFeatures * val)3178 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
3179 {
3180 size_t size = 0;
3181 /* skip val->{sType,pNext} */
3182 size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayDynamicIndexing);
3183 size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayDynamicIndexing);
3184 size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayDynamicIndexing);
3185 size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexing);
3186 size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexing);
3187 size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexing);
3188 size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexing);
3189 size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexing);
3190 size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayNonUniformIndexing);
3191 size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayNonUniformIndexing);
3192 size += vn_sizeof_VkBool32(&val->descriptorBindingUniformBufferUpdateAfterBind);
3193 size += vn_sizeof_VkBool32(&val->descriptorBindingSampledImageUpdateAfterBind);
3194 size += vn_sizeof_VkBool32(&val->descriptorBindingStorageImageUpdateAfterBind);
3195 size += vn_sizeof_VkBool32(&val->descriptorBindingStorageBufferUpdateAfterBind);
3196 size += vn_sizeof_VkBool32(&val->descriptorBindingUniformTexelBufferUpdateAfterBind);
3197 size += vn_sizeof_VkBool32(&val->descriptorBindingStorageTexelBufferUpdateAfterBind);
3198 size += vn_sizeof_VkBool32(&val->descriptorBindingUpdateUnusedWhilePending);
3199 size += vn_sizeof_VkBool32(&val->descriptorBindingPartiallyBound);
3200 size += vn_sizeof_VkBool32(&val->descriptorBindingVariableDescriptorCount);
3201 size += vn_sizeof_VkBool32(&val->runtimeDescriptorArray);
3202 return size;
3203 }
3204
3205 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures * val)3206 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
3207 {
3208 size_t size = 0;
3209
3210 size += vn_sizeof_VkStructureType(&val->sType);
3211 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(val->pNext);
3212 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self(val);
3213
3214 return size;
3215 }
3216
3217 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_encoder * enc,const void * val)3218 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
3219 {
3220 /* no known/supported struct */
3221 vn_encode_simple_pointer(enc, NULL);
3222 }
3223
3224 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingFeatures * val)3225 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
3226 {
3227 /* skip val->{sType,pNext} */
3228 vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayDynamicIndexing);
3229 vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayDynamicIndexing);
3230 vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayDynamicIndexing);
3231 vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayNonUniformIndexing);
3232 vn_encode_VkBool32(enc, &val->shaderSampledImageArrayNonUniformIndexing);
3233 vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayNonUniformIndexing);
3234 vn_encode_VkBool32(enc, &val->shaderStorageImageArrayNonUniformIndexing);
3235 vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayNonUniformIndexing);
3236 vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
3237 vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
3238 vn_encode_VkBool32(enc, &val->descriptorBindingUniformBufferUpdateAfterBind);
3239 vn_encode_VkBool32(enc, &val->descriptorBindingSampledImageUpdateAfterBind);
3240 vn_encode_VkBool32(enc, &val->descriptorBindingStorageImageUpdateAfterBind);
3241 vn_encode_VkBool32(enc, &val->descriptorBindingStorageBufferUpdateAfterBind);
3242 vn_encode_VkBool32(enc, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
3243 vn_encode_VkBool32(enc, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
3244 vn_encode_VkBool32(enc, &val->descriptorBindingUpdateUnusedWhilePending);
3245 vn_encode_VkBool32(enc, &val->descriptorBindingPartiallyBound);
3246 vn_encode_VkBool32(enc, &val->descriptorBindingVariableDescriptorCount);
3247 vn_encode_VkBool32(enc, &val->runtimeDescriptorArray);
3248 }
3249
3250 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingFeatures * val)3251 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
3252 {
3253 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
3254 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES });
3255 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(enc, val->pNext);
3256 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, val);
3257 }
3258
3259 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3260 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3261 {
3262 /* no known/supported struct */
3263 if (vn_decode_simple_pointer(dec))
3264 assert(false);
3265 }
3266
3267 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingFeatures * val)3268 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingFeatures *val)
3269 {
3270 /* skip val->{sType,pNext} */
3271 vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayDynamicIndexing);
3272 vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayDynamicIndexing);
3273 vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayDynamicIndexing);
3274 vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexing);
3275 vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexing);
3276 vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexing);
3277 vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexing);
3278 vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexing);
3279 vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
3280 vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
3281 vn_decode_VkBool32(dec, &val->descriptorBindingUniformBufferUpdateAfterBind);
3282 vn_decode_VkBool32(dec, &val->descriptorBindingSampledImageUpdateAfterBind);
3283 vn_decode_VkBool32(dec, &val->descriptorBindingStorageImageUpdateAfterBind);
3284 vn_decode_VkBool32(dec, &val->descriptorBindingStorageBufferUpdateAfterBind);
3285 vn_decode_VkBool32(dec, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
3286 vn_decode_VkBool32(dec, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
3287 vn_decode_VkBool32(dec, &val->descriptorBindingUpdateUnusedWhilePending);
3288 vn_decode_VkBool32(dec, &val->descriptorBindingPartiallyBound);
3289 vn_decode_VkBool32(dec, &val->descriptorBindingVariableDescriptorCount);
3290 vn_decode_VkBool32(dec, &val->runtimeDescriptorArray);
3291 }
3292
3293 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingFeatures * val)3294 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingFeatures *val)
3295 {
3296 VkStructureType stype;
3297 vn_decode_VkStructureType(dec, &stype);
3298 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
3299
3300 assert(val->sType == stype);
3301 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(dec, val->pNext);
3302 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(dec, val);
3303 }
3304
3305 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(const void * val)3306 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(const void *val)
3307 {
3308 /* no known/supported struct */
3309 return vn_sizeof_simple_pointer(NULL);
3310 }
3311
3312 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(const VkPhysicalDeviceDescriptorIndexingFeatures * val)3313 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
3314 {
3315 size_t size = 0;
3316 /* skip val->{sType,pNext} */
3317 /* skip val->shaderInputAttachmentArrayDynamicIndexing */
3318 /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
3319 /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
3320 /* skip val->shaderUniformBufferArrayNonUniformIndexing */
3321 /* skip val->shaderSampledImageArrayNonUniformIndexing */
3322 /* skip val->shaderStorageBufferArrayNonUniformIndexing */
3323 /* skip val->shaderStorageImageArrayNonUniformIndexing */
3324 /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
3325 /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
3326 /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
3327 /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
3328 /* skip val->descriptorBindingSampledImageUpdateAfterBind */
3329 /* skip val->descriptorBindingStorageImageUpdateAfterBind */
3330 /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
3331 /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
3332 /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
3333 /* skip val->descriptorBindingUpdateUnusedWhilePending */
3334 /* skip val->descriptorBindingPartiallyBound */
3335 /* skip val->descriptorBindingVariableDescriptorCount */
3336 /* skip val->runtimeDescriptorArray */
3337 return size;
3338 }
3339
3340 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_partial(const VkPhysicalDeviceDescriptorIndexingFeatures * val)3341 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_partial(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
3342 {
3343 size_t size = 0;
3344
3345 size += vn_sizeof_VkStructureType(&val->sType);
3346 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(val->pNext);
3347 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(val);
3348
3349 return size;
3350 }
3351
3352 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)3353 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3354 {
3355 /* no known/supported struct */
3356 vn_encode_simple_pointer(enc, NULL);
3357 }
3358
3359 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingFeatures * val)3360 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
3361 {
3362 /* skip val->{sType,pNext} */
3363 /* skip val->shaderInputAttachmentArrayDynamicIndexing */
3364 /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
3365 /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
3366 /* skip val->shaderUniformBufferArrayNonUniformIndexing */
3367 /* skip val->shaderSampledImageArrayNonUniformIndexing */
3368 /* skip val->shaderStorageBufferArrayNonUniformIndexing */
3369 /* skip val->shaderStorageImageArrayNonUniformIndexing */
3370 /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
3371 /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
3372 /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
3373 /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
3374 /* skip val->descriptorBindingSampledImageUpdateAfterBind */
3375 /* skip val->descriptorBindingStorageImageUpdateAfterBind */
3376 /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
3377 /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
3378 /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
3379 /* skip val->descriptorBindingUpdateUnusedWhilePending */
3380 /* skip val->descriptorBindingPartiallyBound */
3381 /* skip val->descriptorBindingVariableDescriptorCount */
3382 /* skip val->runtimeDescriptorArray */
3383 }
3384
3385 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingFeatures * val)3386 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
3387 {
3388 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
3389 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES });
3390 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(enc, val->pNext);
3391 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(enc, val);
3392 }
3393
3394 /* struct VkPhysicalDeviceTimelineSemaphoreFeatures chain */
3395
3396 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(const void * val)3397 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(const void *val)
3398 {
3399 /* no known/supported struct */
3400 return vn_sizeof_simple_pointer(NULL);
3401 }
3402
3403 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self(const VkPhysicalDeviceTimelineSemaphoreFeatures * val)3404 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3405 {
3406 size_t size = 0;
3407 /* skip val->{sType,pNext} */
3408 size += vn_sizeof_VkBool32(&val->timelineSemaphore);
3409 return size;
3410 }
3411
3412 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures * val)3413 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3414 {
3415 size_t size = 0;
3416
3417 size += vn_sizeof_VkStructureType(&val->sType);
3418 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(val->pNext);
3419 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self(val);
3420
3421 return size;
3422 }
3423
3424 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_encoder * enc,const void * val)3425 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
3426 {
3427 /* no known/supported struct */
3428 vn_encode_simple_pointer(enc, NULL);
3429 }
3430
3431 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreFeatures * val)3432 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3433 {
3434 /* skip val->{sType,pNext} */
3435 vn_encode_VkBool32(enc, &val->timelineSemaphore);
3436 }
3437
3438 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreFeatures * val)3439 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3440 {
3441 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
3442 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES });
3443 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(enc, val->pNext);
3444 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, val);
3445 }
3446
3447 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3448 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3449 {
3450 /* no known/supported struct */
3451 if (vn_decode_simple_pointer(dec))
3452 assert(false);
3453 }
3454
3455 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreFeatures * val)3456 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3457 {
3458 /* skip val->{sType,pNext} */
3459 vn_decode_VkBool32(dec, &val->timelineSemaphore);
3460 }
3461
3462 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreFeatures * val)3463 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3464 {
3465 VkStructureType stype;
3466 vn_decode_VkStructureType(dec, &stype);
3467 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
3468
3469 assert(val->sType == stype);
3470 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(dec, val->pNext);
3471 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(dec, val);
3472 }
3473
3474 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(const void * val)3475 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(const void *val)
3476 {
3477 /* no known/supported struct */
3478 return vn_sizeof_simple_pointer(NULL);
3479 }
3480
3481 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures * val)3482 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3483 {
3484 size_t size = 0;
3485 /* skip val->{sType,pNext} */
3486 /* skip val->timelineSemaphore */
3487 return size;
3488 }
3489
3490 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures * val)3491 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3492 {
3493 size_t size = 0;
3494
3495 size += vn_sizeof_VkStructureType(&val->sType);
3496 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(val->pNext);
3497 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(val);
3498
3499 return size;
3500 }
3501
3502 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)3503 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3504 {
3505 /* no known/supported struct */
3506 vn_encode_simple_pointer(enc, NULL);
3507 }
3508
3509 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreFeatures * val)3510 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3511 {
3512 /* skip val->{sType,pNext} */
3513 /* skip val->timelineSemaphore */
3514 }
3515
3516 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreFeatures * val)3517 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3518 {
3519 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
3520 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES });
3521 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(enc, val->pNext);
3522 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(enc, val);
3523 }
3524
3525 /* struct VkPhysicalDevice8BitStorageFeatures chain */
3526
3527 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext(const void * val)3528 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext(const void *val)
3529 {
3530 /* no known/supported struct */
3531 return vn_sizeof_simple_pointer(NULL);
3532 }
3533
3534 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self(const VkPhysicalDevice8BitStorageFeatures * val)3535 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self(const VkPhysicalDevice8BitStorageFeatures *val)
3536 {
3537 size_t size = 0;
3538 /* skip val->{sType,pNext} */
3539 size += vn_sizeof_VkBool32(&val->storageBuffer8BitAccess);
3540 size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer8BitAccess);
3541 size += vn_sizeof_VkBool32(&val->storagePushConstant8);
3542 return size;
3543 }
3544
3545 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures * val)3546 vn_sizeof_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures *val)
3547 {
3548 size_t size = 0;
3549
3550 size += vn_sizeof_VkStructureType(&val->sType);
3551 size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext(val->pNext);
3552 size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self(val);
3553
3554 return size;
3555 }
3556
3557 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_encoder * enc,const void * val)3558 vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
3559 {
3560 /* no known/supported struct */
3561 vn_encode_simple_pointer(enc, NULL);
3562 }
3563
3564 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDevice8BitStorageFeatures * val)3565 vn_encode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
3566 {
3567 /* skip val->{sType,pNext} */
3568 vn_encode_VkBool32(enc, &val->storageBuffer8BitAccess);
3569 vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer8BitAccess);
3570 vn_encode_VkBool32(enc, &val->storagePushConstant8);
3571 }
3572
3573 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_encoder * enc,const VkPhysicalDevice8BitStorageFeatures * val)3574 vn_encode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
3575 {
3576 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
3577 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES });
3578 vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(enc, val->pNext);
3579 vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, val);
3580 }
3581
3582 static inline void
vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3583 vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3584 {
3585 /* no known/supported struct */
3586 if (vn_decode_simple_pointer(dec))
3587 assert(false);
3588 }
3589
3590 static inline void
vn_decode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDevice8BitStorageFeatures * val)3591 vn_decode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDevice8BitStorageFeatures *val)
3592 {
3593 /* skip val->{sType,pNext} */
3594 vn_decode_VkBool32(dec, &val->storageBuffer8BitAccess);
3595 vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer8BitAccess);
3596 vn_decode_VkBool32(dec, &val->storagePushConstant8);
3597 }
3598
3599 static inline void
vn_decode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_decoder * dec,VkPhysicalDevice8BitStorageFeatures * val)3600 vn_decode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_decoder *dec, VkPhysicalDevice8BitStorageFeatures *val)
3601 {
3602 VkStructureType stype;
3603 vn_decode_VkStructureType(dec, &stype);
3604 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
3605
3606 assert(val->sType == stype);
3607 vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext(dec, val->pNext);
3608 vn_decode_VkPhysicalDevice8BitStorageFeatures_self(dec, val);
3609 }
3610
3611 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext_partial(const void * val)3612 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext_partial(const void *val)
3613 {
3614 /* no known/supported struct */
3615 return vn_sizeof_simple_pointer(NULL);
3616 }
3617
3618 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial(const VkPhysicalDevice8BitStorageFeatures * val)3619 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial(const VkPhysicalDevice8BitStorageFeatures *val)
3620 {
3621 size_t size = 0;
3622 /* skip val->{sType,pNext} */
3623 /* skip val->storageBuffer8BitAccess */
3624 /* skip val->uniformAndStorageBuffer8BitAccess */
3625 /* skip val->storagePushConstant8 */
3626 return size;
3627 }
3628
3629 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_partial(const VkPhysicalDevice8BitStorageFeatures * val)3630 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_partial(const VkPhysicalDevice8BitStorageFeatures *val)
3631 {
3632 size_t size = 0;
3633
3634 size += vn_sizeof_VkStructureType(&val->sType);
3635 size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext_partial(val->pNext);
3636 size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial(val);
3637
3638 return size;
3639 }
3640
3641 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)3642 vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3643 {
3644 /* no known/supported struct */
3645 vn_encode_simple_pointer(enc, NULL);
3646 }
3647
3648 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevice8BitStorageFeatures * val)3649 vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
3650 {
3651 /* skip val->{sType,pNext} */
3652 /* skip val->storageBuffer8BitAccess */
3653 /* skip val->uniformAndStorageBuffer8BitAccess */
3654 /* skip val->storagePushConstant8 */
3655 }
3656
3657 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDevice8BitStorageFeatures * val)3658 vn_encode_VkPhysicalDevice8BitStorageFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
3659 {
3660 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
3661 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES });
3662 vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext_partial(enc, val->pNext);
3663 vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(enc, val);
3664 }
3665
3666 /* struct VkPhysicalDeviceConditionalRenderingFeaturesEXT chain */
3667
3668 static inline size_t
vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext(const void * val)3669 vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext(const void *val)
3670 {
3671 /* no known/supported struct */
3672 return vn_sizeof_simple_pointer(NULL);
3673 }
3674
3675 static inline size_t
vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(const VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3676 vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(const VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3677 {
3678 size_t size = 0;
3679 /* skip val->{sType,pNext} */
3680 size += vn_sizeof_VkBool32(&val->conditionalRendering);
3681 size += vn_sizeof_VkBool32(&val->inheritedConditionalRendering);
3682 return size;
3683 }
3684
3685 static inline size_t
vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3686 vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3687 {
3688 size_t size = 0;
3689
3690 size += vn_sizeof_VkStructureType(&val->sType);
3691 size += vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext(val->pNext);
3692 size += vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(val);
3693
3694 return size;
3695 }
3696
3697 static inline void
vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)3698 vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
3699 {
3700 /* no known/supported struct */
3701 vn_encode_simple_pointer(enc, NULL);
3702 }
3703
3704 static inline void
vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3705 vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3706 {
3707 /* skip val->{sType,pNext} */
3708 vn_encode_VkBool32(enc, &val->conditionalRendering);
3709 vn_encode_VkBool32(enc, &val->inheritedConditionalRendering);
3710 }
3711
3712 static inline void
vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3713 vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3714 {
3715 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT);
3716 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT });
3717 vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext(enc, val->pNext);
3718 vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(enc, val);
3719 }
3720
3721 static inline void
vn_decode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)3722 vn_decode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
3723 {
3724 /* no known/supported struct */
3725 if (vn_decode_simple_pointer(dec))
3726 assert(false);
3727 }
3728
3729 static inline void
vn_decode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3730 vn_decode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3731 {
3732 /* skip val->{sType,pNext} */
3733 vn_decode_VkBool32(dec, &val->conditionalRendering);
3734 vn_decode_VkBool32(dec, &val->inheritedConditionalRendering);
3735 }
3736
3737 static inline void
vn_decode_VkPhysicalDeviceConditionalRenderingFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3738 vn_decode_VkPhysicalDeviceConditionalRenderingFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3739 {
3740 VkStructureType stype;
3741 vn_decode_VkStructureType(dec, &stype);
3742 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT);
3743
3744 assert(val->sType == stype);
3745 vn_decode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext(dec, val->pNext);
3746 vn_decode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(dec, val);
3747 }
3748
3749 static inline size_t
vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext_partial(const void * val)3750 vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext_partial(const void *val)
3751 {
3752 /* no known/supported struct */
3753 return vn_sizeof_simple_pointer(NULL);
3754 }
3755
3756 static inline size_t
vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self_partial(const VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3757 vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self_partial(const VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3758 {
3759 size_t size = 0;
3760 /* skip val->{sType,pNext} */
3761 /* skip val->conditionalRendering */
3762 /* skip val->inheritedConditionalRendering */
3763 return size;
3764 }
3765
3766 static inline size_t
vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_partial(const VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3767 vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_partial(const VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3768 {
3769 size_t size = 0;
3770
3771 size += vn_sizeof_VkStructureType(&val->sType);
3772 size += vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext_partial(val->pNext);
3773 size += vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self_partial(val);
3774
3775 return size;
3776 }
3777
3778 static inline void
vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)3779 vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3780 {
3781 /* no known/supported struct */
3782 vn_encode_simple_pointer(enc, NULL);
3783 }
3784
3785 static inline void
vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3786 vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3787 {
3788 /* skip val->{sType,pNext} */
3789 /* skip val->conditionalRendering */
3790 /* skip val->inheritedConditionalRendering */
3791 }
3792
3793 static inline void
vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3794 vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3795 {
3796 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT);
3797 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT });
3798 vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext_partial(enc, val->pNext);
3799 vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self_partial(enc, val);
3800 }
3801
3802 /* struct VkPhysicalDeviceVulkanMemoryModelFeatures chain */
3803
3804 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(const void * val)3805 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(const void *val)
3806 {
3807 /* no known/supported struct */
3808 return vn_sizeof_simple_pointer(NULL);
3809 }
3810
3811 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self(const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3812 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3813 {
3814 size_t size = 0;
3815 /* skip val->{sType,pNext} */
3816 size += vn_sizeof_VkBool32(&val->vulkanMemoryModel);
3817 size += vn_sizeof_VkBool32(&val->vulkanMemoryModelDeviceScope);
3818 size += vn_sizeof_VkBool32(&val->vulkanMemoryModelAvailabilityVisibilityChains);
3819 return size;
3820 }
3821
3822 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3823 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3824 {
3825 size_t size = 0;
3826
3827 size += vn_sizeof_VkStructureType(&val->sType);
3828 size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(val->pNext);
3829 size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self(val);
3830
3831 return size;
3832 }
3833
3834 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_encoder * enc,const void * val)3835 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
3836 {
3837 /* no known/supported struct */
3838 vn_encode_simple_pointer(enc, NULL);
3839 }
3840
3841 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3842 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3843 {
3844 /* skip val->{sType,pNext} */
3845 vn_encode_VkBool32(enc, &val->vulkanMemoryModel);
3846 vn_encode_VkBool32(enc, &val->vulkanMemoryModelDeviceScope);
3847 vn_encode_VkBool32(enc, &val->vulkanMemoryModelAvailabilityVisibilityChains);
3848 }
3849
3850 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3851 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3852 {
3853 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
3854 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES });
3855 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(enc, val->pNext);
3856 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, val);
3857 }
3858
3859 static inline void
vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3860 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3861 {
3862 /* no known/supported struct */
3863 if (vn_decode_simple_pointer(dec))
3864 assert(false);
3865 }
3866
3867 static inline void
vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkanMemoryModelFeatures * val)3868 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3869 {
3870 /* skip val->{sType,pNext} */
3871 vn_decode_VkBool32(dec, &val->vulkanMemoryModel);
3872 vn_decode_VkBool32(dec, &val->vulkanMemoryModelDeviceScope);
3873 vn_decode_VkBool32(dec, &val->vulkanMemoryModelAvailabilityVisibilityChains);
3874 }
3875
3876 static inline void
vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkanMemoryModelFeatures * val)3877 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3878 {
3879 VkStructureType stype;
3880 vn_decode_VkStructureType(dec, &stype);
3881 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
3882
3883 assert(val->sType == stype);
3884 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(dec, val->pNext);
3885 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(dec, val);
3886 }
3887
3888 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(const void * val)3889 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(const void *val)
3890 {
3891 /* no known/supported struct */
3892 return vn_sizeof_simple_pointer(NULL);
3893 }
3894
3895 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3896 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3897 {
3898 size_t size = 0;
3899 /* skip val->{sType,pNext} */
3900 /* skip val->vulkanMemoryModel */
3901 /* skip val->vulkanMemoryModelDeviceScope */
3902 /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
3903 return size;
3904 }
3905
3906 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3907 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3908 {
3909 size_t size = 0;
3910
3911 size += vn_sizeof_VkStructureType(&val->sType);
3912 size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(val->pNext);
3913 size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(val);
3914
3915 return size;
3916 }
3917
3918 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)3919 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3920 {
3921 /* no known/supported struct */
3922 vn_encode_simple_pointer(enc, NULL);
3923 }
3924
3925 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3926 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3927 {
3928 /* skip val->{sType,pNext} */
3929 /* skip val->vulkanMemoryModel */
3930 /* skip val->vulkanMemoryModelDeviceScope */
3931 /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
3932 }
3933
3934 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3935 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3936 {
3937 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
3938 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES });
3939 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(enc, val->pNext);
3940 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(enc, val);
3941 }
3942
3943 /* struct VkPhysicalDeviceShaderAtomicInt64Features chain */
3944
3945 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext(const void * val)3946 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext(const void *val)
3947 {
3948 /* no known/supported struct */
3949 return vn_sizeof_simple_pointer(NULL);
3950 }
3951
3952 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self(const VkPhysicalDeviceShaderAtomicInt64Features * val)3953 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self(const VkPhysicalDeviceShaderAtomicInt64Features *val)
3954 {
3955 size_t size = 0;
3956 /* skip val->{sType,pNext} */
3957 size += vn_sizeof_VkBool32(&val->shaderBufferInt64Atomics);
3958 size += vn_sizeof_VkBool32(&val->shaderSharedInt64Atomics);
3959 return size;
3960 }
3961
3962 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features * val)3963 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features *val)
3964 {
3965 size_t size = 0;
3966
3967 size += vn_sizeof_VkStructureType(&val->sType);
3968 size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext(val->pNext);
3969 size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self(val);
3970
3971 return size;
3972 }
3973
3974 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_encoder * enc,const void * val)3975 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_encoder *enc, const void *val)
3976 {
3977 /* no known/supported struct */
3978 vn_encode_simple_pointer(enc, NULL);
3979 }
3980
3981 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderAtomicInt64Features * val)3982 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
3983 {
3984 /* skip val->{sType,pNext} */
3985 vn_encode_VkBool32(enc, &val->shaderBufferInt64Atomics);
3986 vn_encode_VkBool32(enc, &val->shaderSharedInt64Atomics);
3987 }
3988
3989 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderAtomicInt64Features * val)3990 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
3991 {
3992 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
3993 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES });
3994 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(enc, val->pNext);
3995 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, val);
3996 }
3997
3998 static inline void
vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_decoder * dec,const void * val)3999 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_decoder *dec, const void *val)
4000 {
4001 /* no known/supported struct */
4002 if (vn_decode_simple_pointer(dec))
4003 assert(false);
4004 }
4005
4006 static inline void
vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderAtomicInt64Features * val)4007 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderAtomicInt64Features *val)
4008 {
4009 /* skip val->{sType,pNext} */
4010 vn_decode_VkBool32(dec, &val->shaderBufferInt64Atomics);
4011 vn_decode_VkBool32(dec, &val->shaderSharedInt64Atomics);
4012 }
4013
4014 static inline void
vn_decode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderAtomicInt64Features * val)4015 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderAtomicInt64Features *val)
4016 {
4017 VkStructureType stype;
4018 vn_decode_VkStructureType(dec, &stype);
4019 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
4020
4021 assert(val->sType == stype);
4022 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(dec, val->pNext);
4023 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(dec, val);
4024 }
4025
4026 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(const void * val)4027 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(const void *val)
4028 {
4029 /* no known/supported struct */
4030 return vn_sizeof_simple_pointer(NULL);
4031 }
4032
4033 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(const VkPhysicalDeviceShaderAtomicInt64Features * val)4034 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(const VkPhysicalDeviceShaderAtomicInt64Features *val)
4035 {
4036 size_t size = 0;
4037 /* skip val->{sType,pNext} */
4038 /* skip val->shaderBufferInt64Atomics */
4039 /* skip val->shaderSharedInt64Atomics */
4040 return size;
4041 }
4042
4043 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_partial(const VkPhysicalDeviceShaderAtomicInt64Features * val)4044 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_partial(const VkPhysicalDeviceShaderAtomicInt64Features *val)
4045 {
4046 size_t size = 0;
4047
4048 size += vn_sizeof_VkStructureType(&val->sType);
4049 size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(val->pNext);
4050 size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(val);
4051
4052 return size;
4053 }
4054
4055 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)4056 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4057 {
4058 /* no known/supported struct */
4059 vn_encode_simple_pointer(enc, NULL);
4060 }
4061
4062 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderAtomicInt64Features * val)4063 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
4064 {
4065 /* skip val->{sType,pNext} */
4066 /* skip val->shaderBufferInt64Atomics */
4067 /* skip val->shaderSharedInt64Atomics */
4068 }
4069
4070 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderAtomicInt64Features * val)4071 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
4072 {
4073 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
4074 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES });
4075 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(enc, val->pNext);
4076 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(enc, val);
4077 }
4078
4079 /* struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT chain */
4080
4081 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext(const void * val)4082 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext(const void *val)
4083 {
4084 /* no known/supported struct */
4085 return vn_sizeof_simple_pointer(NULL);
4086 }
4087
4088 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)4089 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
4090 {
4091 size_t size = 0;
4092 /* skip val->{sType,pNext} */
4093 size += vn_sizeof_VkBool32(&val->vertexAttributeInstanceRateDivisor);
4094 size += vn_sizeof_VkBool32(&val->vertexAttributeInstanceRateZeroDivisor);
4095 return size;
4096 }
4097
4098 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)4099 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
4100 {
4101 size_t size = 0;
4102
4103 size += vn_sizeof_VkStructureType(&val->sType);
4104 size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext(val->pNext);
4105 size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(val);
4106
4107 return size;
4108 }
4109
4110 static inline void
vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)4111 vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
4112 {
4113 /* no known/supported struct */
4114 vn_encode_simple_pointer(enc, NULL);
4115 }
4116
4117 static inline void
vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)4118 vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
4119 {
4120 /* skip val->{sType,pNext} */
4121 vn_encode_VkBool32(enc, &val->vertexAttributeInstanceRateDivisor);
4122 vn_encode_VkBool32(enc, &val->vertexAttributeInstanceRateZeroDivisor);
4123 }
4124
4125 static inline void
vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)4126 vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
4127 {
4128 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT);
4129 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT });
4130 vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext(enc, val->pNext);
4131 vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(enc, val);
4132 }
4133
4134 static inline void
vn_decode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)4135 vn_decode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
4136 {
4137 /* no known/supported struct */
4138 if (vn_decode_simple_pointer(dec))
4139 assert(false);
4140 }
4141
4142 static inline void
vn_decode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)4143 vn_decode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
4144 {
4145 /* skip val->{sType,pNext} */
4146 vn_decode_VkBool32(dec, &val->vertexAttributeInstanceRateDivisor);
4147 vn_decode_VkBool32(dec, &val->vertexAttributeInstanceRateZeroDivisor);
4148 }
4149
4150 static inline void
vn_decode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)4151 vn_decode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
4152 {
4153 VkStructureType stype;
4154 vn_decode_VkStructureType(dec, &stype);
4155 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT);
4156
4157 assert(val->sType == stype);
4158 vn_decode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext(dec, val->pNext);
4159 vn_decode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(dec, val);
4160 }
4161
4162 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext_partial(const void * val)4163 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext_partial(const void *val)
4164 {
4165 /* no known/supported struct */
4166 return vn_sizeof_simple_pointer(NULL);
4167 }
4168
4169 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self_partial(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)4170 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self_partial(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
4171 {
4172 size_t size = 0;
4173 /* skip val->{sType,pNext} */
4174 /* skip val->vertexAttributeInstanceRateDivisor */
4175 /* skip val->vertexAttributeInstanceRateZeroDivisor */
4176 return size;
4177 }
4178
4179 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_partial(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)4180 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_partial(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
4181 {
4182 size_t size = 0;
4183
4184 size += vn_sizeof_VkStructureType(&val->sType);
4185 size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext_partial(val->pNext);
4186 size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self_partial(val);
4187
4188 return size;
4189 }
4190
4191 static inline void
vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)4192 vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4193 {
4194 /* no known/supported struct */
4195 vn_encode_simple_pointer(enc, NULL);
4196 }
4197
4198 static inline void
vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)4199 vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
4200 {
4201 /* skip val->{sType,pNext} */
4202 /* skip val->vertexAttributeInstanceRateDivisor */
4203 /* skip val->vertexAttributeInstanceRateZeroDivisor */
4204 }
4205
4206 static inline void
vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)4207 vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
4208 {
4209 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT);
4210 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT });
4211 vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext_partial(enc, val->pNext);
4212 vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self_partial(enc, val);
4213 }
4214
4215 /* struct VkPhysicalDeviceTransformFeedbackFeaturesEXT chain */
4216
4217 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(const void * val)4218 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(const void *val)
4219 {
4220 /* no known/supported struct */
4221 return vn_sizeof_simple_pointer(NULL);
4222 }
4223
4224 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)4225 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
4226 {
4227 size_t size = 0;
4228 /* skip val->{sType,pNext} */
4229 size += vn_sizeof_VkBool32(&val->transformFeedback);
4230 size += vn_sizeof_VkBool32(&val->geometryStreams);
4231 return size;
4232 }
4233
4234 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)4235 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
4236 {
4237 size_t size = 0;
4238
4239 size += vn_sizeof_VkStructureType(&val->sType);
4240 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(val->pNext);
4241 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(val);
4242
4243 return size;
4244 }
4245
4246 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)4247 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
4248 {
4249 /* no known/supported struct */
4250 vn_encode_simple_pointer(enc, NULL);
4251 }
4252
4253 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)4254 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
4255 {
4256 /* skip val->{sType,pNext} */
4257 vn_encode_VkBool32(enc, &val->transformFeedback);
4258 vn_encode_VkBool32(enc, &val->geometryStreams);
4259 }
4260
4261 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)4262 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
4263 {
4264 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
4265 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT });
4266 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(enc, val->pNext);
4267 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, val);
4268 }
4269
4270 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)4271 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
4272 {
4273 /* no known/supported struct */
4274 if (vn_decode_simple_pointer(dec))
4275 assert(false);
4276 }
4277
4278 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)4279 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
4280 {
4281 /* skip val->{sType,pNext} */
4282 vn_decode_VkBool32(dec, &val->transformFeedback);
4283 vn_decode_VkBool32(dec, &val->geometryStreams);
4284 }
4285
4286 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)4287 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
4288 {
4289 VkStructureType stype;
4290 vn_decode_VkStructureType(dec, &stype);
4291 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
4292
4293 assert(val->sType == stype);
4294 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(dec, val->pNext);
4295 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(dec, val);
4296 }
4297
4298 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(const void * val)4299 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(const void *val)
4300 {
4301 /* no known/supported struct */
4302 return vn_sizeof_simple_pointer(NULL);
4303 }
4304
4305 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)4306 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
4307 {
4308 size_t size = 0;
4309 /* skip val->{sType,pNext} */
4310 /* skip val->transformFeedback */
4311 /* skip val->geometryStreams */
4312 return size;
4313 }
4314
4315 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)4316 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
4317 {
4318 size_t size = 0;
4319
4320 size += vn_sizeof_VkStructureType(&val->sType);
4321 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(val->pNext);
4322 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(val);
4323
4324 return size;
4325 }
4326
4327 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)4328 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4329 {
4330 /* no known/supported struct */
4331 vn_encode_simple_pointer(enc, NULL);
4332 }
4333
4334 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)4335 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
4336 {
4337 /* skip val->{sType,pNext} */
4338 /* skip val->transformFeedback */
4339 /* skip val->geometryStreams */
4340 }
4341
4342 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)4343 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
4344 {
4345 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
4346 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT });
4347 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(enc, val->pNext);
4348 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(enc, val);
4349 }
4350
4351 /* struct VkPhysicalDeviceScalarBlockLayoutFeatures chain */
4352
4353 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(const void * val)4354 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_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_VkPhysicalDeviceScalarBlockLayoutFeatures_self(const VkPhysicalDeviceScalarBlockLayoutFeatures * val)4361 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4362 {
4363 size_t size = 0;
4364 /* skip val->{sType,pNext} */
4365 size += vn_sizeof_VkBool32(&val->scalarBlockLayout);
4366 return size;
4367 }
4368
4369 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures * val)4370 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4371 {
4372 size_t size = 0;
4373
4374 size += vn_sizeof_VkStructureType(&val->sType);
4375 size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(val->pNext);
4376 size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self(val);
4377
4378 return size;
4379 }
4380
4381 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_encoder * enc,const void * val)4382 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_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_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceScalarBlockLayoutFeatures * val)4389 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4390 {
4391 /* skip val->{sType,pNext} */
4392 vn_encode_VkBool32(enc, &val->scalarBlockLayout);
4393 }
4394
4395 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceScalarBlockLayoutFeatures * val)4396 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4397 {
4398 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
4399 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES });
4400 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(enc, val->pNext);
4401 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, val);
4402 }
4403
4404 static inline void
vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_decoder * dec,const void * val)4405 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_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_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceScalarBlockLayoutFeatures * val)4413 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4414 {
4415 /* skip val->{sType,pNext} */
4416 vn_decode_VkBool32(dec, &val->scalarBlockLayout);
4417 }
4418
4419 static inline void
vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceScalarBlockLayoutFeatures * val)4420 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4421 {
4422 VkStructureType stype;
4423 vn_decode_VkStructureType(dec, &stype);
4424 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
4425
4426 assert(val->sType == stype);
4427 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(dec, val->pNext);
4428 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(dec, val);
4429 }
4430
4431 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(const void * val)4432 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_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_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures * val)4439 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4440 {
4441 size_t size = 0;
4442 /* skip val->{sType,pNext} */
4443 /* skip val->scalarBlockLayout */
4444 return size;
4445 }
4446
4447 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures * val)4448 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4449 {
4450 size_t size = 0;
4451
4452 size += vn_sizeof_VkStructureType(&val->sType);
4453 size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(val->pNext);
4454 size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(val);
4455
4456 return size;
4457 }
4458
4459 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)4460 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_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_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceScalarBlockLayoutFeatures * val)4467 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4468 {
4469 /* skip val->{sType,pNext} */
4470 /* skip val->scalarBlockLayout */
4471 }
4472
4473 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceScalarBlockLayoutFeatures * val)4474 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4475 {
4476 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
4477 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES });
4478 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(enc, val->pNext);
4479 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(enc, val);
4480 }
4481
4482 /* struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures chain */
4483
4484 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(const void * val)4485 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_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_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4492 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4493 {
4494 size_t size = 0;
4495 /* skip val->{sType,pNext} */
4496 size += vn_sizeof_VkBool32(&val->uniformBufferStandardLayout);
4497 return size;
4498 }
4499
4500 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4501 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4502 {
4503 size_t size = 0;
4504
4505 size += vn_sizeof_VkStructureType(&val->sType);
4506 size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(val->pNext);
4507 size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(val);
4508
4509 return size;
4510 }
4511
4512 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_encoder * enc,const void * val)4513 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
4514 {
4515 /* no known/supported struct */
4516 vn_encode_simple_pointer(enc, NULL);
4517 }
4518
4519 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4520 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4521 {
4522 /* skip val->{sType,pNext} */
4523 vn_encode_VkBool32(enc, &val->uniformBufferStandardLayout);
4524 }
4525
4526 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4527 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4528 {
4529 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
4530 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES });
4531 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(enc, val->pNext);
4532 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, val);
4533 }
4534
4535 static inline void
vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_decoder * dec,const void * val)4536 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
4537 {
4538 /* no known/supported struct */
4539 if (vn_decode_simple_pointer(dec))
4540 assert(false);
4541 }
4542
4543 static inline void
vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4544 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4545 {
4546 /* skip val->{sType,pNext} */
4547 vn_decode_VkBool32(dec, &val->uniformBufferStandardLayout);
4548 }
4549
4550 static inline void
vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4551 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4552 {
4553 VkStructureType stype;
4554 vn_decode_VkStructureType(dec, &stype);
4555 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
4556
4557 assert(val->sType == stype);
4558 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(dec, val->pNext);
4559 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(dec, val);
4560 }
4561
4562 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(const void * val)4563 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(const void *val)
4564 {
4565 /* no known/supported struct */
4566 return vn_sizeof_simple_pointer(NULL);
4567 }
4568
4569 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4570 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4571 {
4572 size_t size = 0;
4573 /* skip val->{sType,pNext} */
4574 /* skip val->uniformBufferStandardLayout */
4575 return size;
4576 }
4577
4578 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4579 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4580 {
4581 size_t size = 0;
4582
4583 size += vn_sizeof_VkStructureType(&val->sType);
4584 size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(val->pNext);
4585 size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(val);
4586
4587 return size;
4588 }
4589
4590 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)4591 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4592 {
4593 /* no known/supported struct */
4594 vn_encode_simple_pointer(enc, NULL);
4595 }
4596
4597 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4598 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4599 {
4600 /* skip val->{sType,pNext} */
4601 /* skip val->uniformBufferStandardLayout */
4602 }
4603
4604 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4605 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4606 {
4607 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
4608 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES });
4609 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(enc, val->pNext);
4610 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(enc, val);
4611 }
4612
4613 /* struct VkPhysicalDeviceDepthClipEnableFeaturesEXT chain */
4614
4615 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext(const void * val)4616 vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext(const void *val)
4617 {
4618 /* no known/supported struct */
4619 return vn_sizeof_simple_pointer(NULL);
4620 }
4621
4622 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(const VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4623 vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(const VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4624 {
4625 size_t size = 0;
4626 /* skip val->{sType,pNext} */
4627 size += vn_sizeof_VkBool32(&val->depthClipEnable);
4628 return size;
4629 }
4630
4631 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4632 vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4633 {
4634 size_t size = 0;
4635
4636 size += vn_sizeof_VkStructureType(&val->sType);
4637 size += vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext(val->pNext);
4638 size += vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(val);
4639
4640 return size;
4641 }
4642
4643 static inline void
vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)4644 vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
4645 {
4646 /* no known/supported struct */
4647 vn_encode_simple_pointer(enc, NULL);
4648 }
4649
4650 static inline void
vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4651 vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4652 {
4653 /* skip val->{sType,pNext} */
4654 vn_encode_VkBool32(enc, &val->depthClipEnable);
4655 }
4656
4657 static inline void
vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4658 vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4659 {
4660 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT);
4661 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT });
4662 vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext(enc, val->pNext);
4663 vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(enc, val);
4664 }
4665
4666 static inline void
vn_decode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)4667 vn_decode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
4668 {
4669 /* no known/supported struct */
4670 if (vn_decode_simple_pointer(dec))
4671 assert(false);
4672 }
4673
4674 static inline void
vn_decode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4675 vn_decode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4676 {
4677 /* skip val->{sType,pNext} */
4678 vn_decode_VkBool32(dec, &val->depthClipEnable);
4679 }
4680
4681 static inline void
vn_decode_VkPhysicalDeviceDepthClipEnableFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4682 vn_decode_VkPhysicalDeviceDepthClipEnableFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4683 {
4684 VkStructureType stype;
4685 vn_decode_VkStructureType(dec, &stype);
4686 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT);
4687
4688 assert(val->sType == stype);
4689 vn_decode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext(dec, val->pNext);
4690 vn_decode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(dec, val);
4691 }
4692
4693 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext_partial(const void * val)4694 vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext_partial(const void *val)
4695 {
4696 /* no known/supported struct */
4697 return vn_sizeof_simple_pointer(NULL);
4698 }
4699
4700 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self_partial(const VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4701 vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self_partial(const VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4702 {
4703 size_t size = 0;
4704 /* skip val->{sType,pNext} */
4705 /* skip val->depthClipEnable */
4706 return size;
4707 }
4708
4709 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_partial(const VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4710 vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_partial(const VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4711 {
4712 size_t size = 0;
4713
4714 size += vn_sizeof_VkStructureType(&val->sType);
4715 size += vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext_partial(val->pNext);
4716 size += vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self_partial(val);
4717
4718 return size;
4719 }
4720
4721 static inline void
vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)4722 vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4723 {
4724 /* no known/supported struct */
4725 vn_encode_simple_pointer(enc, NULL);
4726 }
4727
4728 static inline void
vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4729 vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4730 {
4731 /* skip val->{sType,pNext} */
4732 /* skip val->depthClipEnable */
4733 }
4734
4735 static inline void
vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4736 vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4737 {
4738 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT);
4739 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT });
4740 vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext_partial(enc, val->pNext);
4741 vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self_partial(enc, val);
4742 }
4743
4744 /* struct VkPhysicalDeviceBufferDeviceAddressFeatures chain */
4745
4746 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(const void * val)4747 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(const void *val)
4748 {
4749 /* no known/supported struct */
4750 return vn_sizeof_simple_pointer(NULL);
4751 }
4752
4753 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self(const VkPhysicalDeviceBufferDeviceAddressFeatures * val)4754 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4755 {
4756 size_t size = 0;
4757 /* skip val->{sType,pNext} */
4758 size += vn_sizeof_VkBool32(&val->bufferDeviceAddress);
4759 size += vn_sizeof_VkBool32(&val->bufferDeviceAddressCaptureReplay);
4760 size += vn_sizeof_VkBool32(&val->bufferDeviceAddressMultiDevice);
4761 return size;
4762 }
4763
4764 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures * val)4765 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4766 {
4767 size_t size = 0;
4768
4769 size += vn_sizeof_VkStructureType(&val->sType);
4770 size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(val->pNext);
4771 size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self(val);
4772
4773 return size;
4774 }
4775
4776 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_encoder * enc,const void * val)4777 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
4778 {
4779 /* no known/supported struct */
4780 vn_encode_simple_pointer(enc, NULL);
4781 }
4782
4783 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceBufferDeviceAddressFeatures * val)4784 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4785 {
4786 /* skip val->{sType,pNext} */
4787 vn_encode_VkBool32(enc, &val->bufferDeviceAddress);
4788 vn_encode_VkBool32(enc, &val->bufferDeviceAddressCaptureReplay);
4789 vn_encode_VkBool32(enc, &val->bufferDeviceAddressMultiDevice);
4790 }
4791
4792 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceBufferDeviceAddressFeatures * val)4793 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4794 {
4795 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
4796 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES });
4797 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(enc, val->pNext);
4798 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, val);
4799 }
4800
4801 static inline void
vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_decoder * dec,const void * val)4802 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
4803 {
4804 /* no known/supported struct */
4805 if (vn_decode_simple_pointer(dec))
4806 assert(false);
4807 }
4808
4809 static inline void
vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceBufferDeviceAddressFeatures * val)4810 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4811 {
4812 /* skip val->{sType,pNext} */
4813 vn_decode_VkBool32(dec, &val->bufferDeviceAddress);
4814 vn_decode_VkBool32(dec, &val->bufferDeviceAddressCaptureReplay);
4815 vn_decode_VkBool32(dec, &val->bufferDeviceAddressMultiDevice);
4816 }
4817
4818 static inline void
vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceBufferDeviceAddressFeatures * val)4819 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4820 {
4821 VkStructureType stype;
4822 vn_decode_VkStructureType(dec, &stype);
4823 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
4824
4825 assert(val->sType == stype);
4826 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(dec, val->pNext);
4827 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(dec, val);
4828 }
4829
4830 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(const void * val)4831 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(const void *val)
4832 {
4833 /* no known/supported struct */
4834 return vn_sizeof_simple_pointer(NULL);
4835 }
4836
4837 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures * val)4838 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4839 {
4840 size_t size = 0;
4841 /* skip val->{sType,pNext} */
4842 /* skip val->bufferDeviceAddress */
4843 /* skip val->bufferDeviceAddressCaptureReplay */
4844 /* skip val->bufferDeviceAddressMultiDevice */
4845 return size;
4846 }
4847
4848 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures * val)4849 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4850 {
4851 size_t size = 0;
4852
4853 size += vn_sizeof_VkStructureType(&val->sType);
4854 size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(val->pNext);
4855 size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(val);
4856
4857 return size;
4858 }
4859
4860 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)4861 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4862 {
4863 /* no known/supported struct */
4864 vn_encode_simple_pointer(enc, NULL);
4865 }
4866
4867 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceBufferDeviceAddressFeatures * val)4868 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4869 {
4870 /* skip val->{sType,pNext} */
4871 /* skip val->bufferDeviceAddress */
4872 /* skip val->bufferDeviceAddressCaptureReplay */
4873 /* skip val->bufferDeviceAddressMultiDevice */
4874 }
4875
4876 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceBufferDeviceAddressFeatures * val)4877 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4878 {
4879 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
4880 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES });
4881 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(enc, val->pNext);
4882 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(enc, val);
4883 }
4884
4885 /* struct VkPhysicalDeviceImagelessFramebufferFeatures chain */
4886
4887 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(const void * val)4888 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_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_VkPhysicalDeviceImagelessFramebufferFeatures_self(const VkPhysicalDeviceImagelessFramebufferFeatures * val)4895 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
4896 {
4897 size_t size = 0;
4898 /* skip val->{sType,pNext} */
4899 size += vn_sizeof_VkBool32(&val->imagelessFramebuffer);
4900 return size;
4901 }
4902
4903 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures * val)4904 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
4905 {
4906 size_t size = 0;
4907
4908 size += vn_sizeof_VkStructureType(&val->sType);
4909 size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(val->pNext);
4910 size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self(val);
4911
4912 return size;
4913 }
4914
4915 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_encoder * enc,const void * val)4916 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_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_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceImagelessFramebufferFeatures * val)4923 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
4924 {
4925 /* skip val->{sType,pNext} */
4926 vn_encode_VkBool32(enc, &val->imagelessFramebuffer);
4927 }
4928
4929 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceImagelessFramebufferFeatures * val)4930 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
4931 {
4932 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
4933 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES });
4934 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(enc, val->pNext);
4935 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, val);
4936 }
4937
4938 static inline void
vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_decoder * dec,const void * val)4939 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_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_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceImagelessFramebufferFeatures * val)4947 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceImagelessFramebufferFeatures *val)
4948 {
4949 /* skip val->{sType,pNext} */
4950 vn_decode_VkBool32(dec, &val->imagelessFramebuffer);
4951 }
4952
4953 static inline void
vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceImagelessFramebufferFeatures * val)4954 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceImagelessFramebufferFeatures *val)
4955 {
4956 VkStructureType stype;
4957 vn_decode_VkStructureType(dec, &stype);
4958 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
4959
4960 assert(val->sType == stype);
4961 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(dec, val->pNext);
4962 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(dec, val);
4963 }
4964
4965 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(const void * val)4966 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_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_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(const VkPhysicalDeviceImagelessFramebufferFeatures * val)4973 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
4974 {
4975 size_t size = 0;
4976 /* skip val->{sType,pNext} */
4977 /* skip val->imagelessFramebuffer */
4978 return size;
4979 }
4980
4981 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_partial(const VkPhysicalDeviceImagelessFramebufferFeatures * val)4982 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_partial(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
4983 {
4984 size_t size = 0;
4985
4986 size += vn_sizeof_VkStructureType(&val->sType);
4987 size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(val->pNext);
4988 size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(val);
4989
4990 return size;
4991 }
4992
4993 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)4994 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_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_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceImagelessFramebufferFeatures * val)5001 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
5002 {
5003 /* skip val->{sType,pNext} */
5004 /* skip val->imagelessFramebuffer */
5005 }
5006
5007 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceImagelessFramebufferFeatures * val)5008 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
5009 {
5010 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
5011 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES });
5012 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(enc, val->pNext);
5013 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(enc, val);
5014 }
5015
5016 /* struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures chain */
5017
5018 static inline size_t
vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(const void * val)5019 vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_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_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)5026 vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
5027 {
5028 size_t size = 0;
5029 /* skip val->{sType,pNext} */
5030 size += vn_sizeof_VkBool32(&val->textureCompressionASTC_HDR);
5031 return size;
5032 }
5033
5034 static inline size_t
vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)5035 vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
5036 {
5037 size_t size = 0;
5038
5039 size += vn_sizeof_VkStructureType(&val->sType);
5040 size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(val->pNext);
5041 size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(val);
5042
5043 return size;
5044 }
5045
5046 static inline void
vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(struct vn_cs_encoder * enc,const void * val)5047 vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_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_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)5054 vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
5055 {
5056 /* skip val->{sType,pNext} */
5057 vn_encode_VkBool32(enc, &val->textureCompressionASTC_HDR);
5058 }
5059
5060 static inline void
vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)5061 vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
5062 {
5063 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES);
5064 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES });
5065 vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(enc, val->pNext);
5066 vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(enc, val);
5067 }
5068
5069 static inline void
vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(struct vn_cs_decoder * dec,const void * val)5070 vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_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_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)5078 vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
5079 {
5080 /* skip val->{sType,pNext} */
5081 vn_decode_VkBool32(dec, &val->textureCompressionASTC_HDR);
5082 }
5083
5084 static inline void
vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)5085 vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
5086 {
5087 VkStructureType stype;
5088 vn_decode_VkStructureType(dec, &stype);
5089 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES);
5090
5091 assert(val->sType == stype);
5092 vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(dec, val->pNext);
5093 vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(dec, val);
5094 }
5095
5096 static inline size_t
vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext_partial(const void * val)5097 vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_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_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)5104 vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
5105 {
5106 size_t size = 0;
5107 /* skip val->{sType,pNext} */
5108 /* skip val->textureCompressionASTC_HDR */
5109 return size;
5110 }
5111
5112 static inline size_t
vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_partial(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)5113 vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_partial(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
5114 {
5115 size_t size = 0;
5116
5117 size += vn_sizeof_VkStructureType(&val->sType);
5118 size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext_partial(val->pNext);
5119 size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial(val);
5120
5121 return size;
5122 }
5123
5124 static inline void
vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)5125 vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_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_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)5132 vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
5133 {
5134 /* skip val->{sType,pNext} */
5135 /* skip val->textureCompressionASTC_HDR */
5136 }
5137
5138 static inline void
vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)5139 vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
5140 {
5141 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES);
5142 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES });
5143 vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext_partial(enc, val->pNext);
5144 vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial(enc, val);
5145 }
5146
5147 /* struct VkPhysicalDeviceShaderClockFeaturesKHR chain */
5148
5149 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderClockFeaturesKHR_pnext(const void * val)5150 vn_sizeof_VkPhysicalDeviceShaderClockFeaturesKHR_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_VkPhysicalDeviceShaderClockFeaturesKHR_self(const VkPhysicalDeviceShaderClockFeaturesKHR * val)5157 vn_sizeof_VkPhysicalDeviceShaderClockFeaturesKHR_self(const VkPhysicalDeviceShaderClockFeaturesKHR *val)
5158 {
5159 size_t size = 0;
5160 /* skip val->{sType,pNext} */
5161 size += vn_sizeof_VkBool32(&val->shaderSubgroupClock);
5162 size += vn_sizeof_VkBool32(&val->shaderDeviceClock);
5163 return size;
5164 }
5165
5166 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderClockFeaturesKHR(const VkPhysicalDeviceShaderClockFeaturesKHR * val)5167 vn_sizeof_VkPhysicalDeviceShaderClockFeaturesKHR(const VkPhysicalDeviceShaderClockFeaturesKHR *val)
5168 {
5169 size_t size = 0;
5170
5171 size += vn_sizeof_VkStructureType(&val->sType);
5172 size += vn_sizeof_VkPhysicalDeviceShaderClockFeaturesKHR_pnext(val->pNext);
5173 size += vn_sizeof_VkPhysicalDeviceShaderClockFeaturesKHR_self(val);
5174
5175 return size;
5176 }
5177
5178 static inline void
vn_encode_VkPhysicalDeviceShaderClockFeaturesKHR_pnext(struct vn_cs_encoder * enc,const void * val)5179 vn_encode_VkPhysicalDeviceShaderClockFeaturesKHR_pnext(struct vn_cs_encoder *enc, const void *val)
5180 {
5181 /* no known/supported struct */
5182 vn_encode_simple_pointer(enc, NULL);
5183 }
5184
5185 static inline void
vn_encode_VkPhysicalDeviceShaderClockFeaturesKHR_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderClockFeaturesKHR * val)5186 vn_encode_VkPhysicalDeviceShaderClockFeaturesKHR_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderClockFeaturesKHR *val)
5187 {
5188 /* skip val->{sType,pNext} */
5189 vn_encode_VkBool32(enc, &val->shaderSubgroupClock);
5190 vn_encode_VkBool32(enc, &val->shaderDeviceClock);
5191 }
5192
5193 static inline void
vn_encode_VkPhysicalDeviceShaderClockFeaturesKHR(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderClockFeaturesKHR * val)5194 vn_encode_VkPhysicalDeviceShaderClockFeaturesKHR(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderClockFeaturesKHR *val)
5195 {
5196 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR);
5197 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR });
5198 vn_encode_VkPhysicalDeviceShaderClockFeaturesKHR_pnext(enc, val->pNext);
5199 vn_encode_VkPhysicalDeviceShaderClockFeaturesKHR_self(enc, val);
5200 }
5201
5202 static inline void
vn_decode_VkPhysicalDeviceShaderClockFeaturesKHR_pnext(struct vn_cs_decoder * dec,const void * val)5203 vn_decode_VkPhysicalDeviceShaderClockFeaturesKHR_pnext(struct vn_cs_decoder *dec, const void *val)
5204 {
5205 /* no known/supported struct */
5206 if (vn_decode_simple_pointer(dec))
5207 assert(false);
5208 }
5209
5210 static inline void
vn_decode_VkPhysicalDeviceShaderClockFeaturesKHR_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderClockFeaturesKHR * val)5211 vn_decode_VkPhysicalDeviceShaderClockFeaturesKHR_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderClockFeaturesKHR *val)
5212 {
5213 /* skip val->{sType,pNext} */
5214 vn_decode_VkBool32(dec, &val->shaderSubgroupClock);
5215 vn_decode_VkBool32(dec, &val->shaderDeviceClock);
5216 }
5217
5218 static inline void
vn_decode_VkPhysicalDeviceShaderClockFeaturesKHR(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderClockFeaturesKHR * val)5219 vn_decode_VkPhysicalDeviceShaderClockFeaturesKHR(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderClockFeaturesKHR *val)
5220 {
5221 VkStructureType stype;
5222 vn_decode_VkStructureType(dec, &stype);
5223 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR);
5224
5225 assert(val->sType == stype);
5226 vn_decode_VkPhysicalDeviceShaderClockFeaturesKHR_pnext(dec, val->pNext);
5227 vn_decode_VkPhysicalDeviceShaderClockFeaturesKHR_self(dec, val);
5228 }
5229
5230 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderClockFeaturesKHR_pnext_partial(const void * val)5231 vn_sizeof_VkPhysicalDeviceShaderClockFeaturesKHR_pnext_partial(const void *val)
5232 {
5233 /* no known/supported struct */
5234 return vn_sizeof_simple_pointer(NULL);
5235 }
5236
5237 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderClockFeaturesKHR_self_partial(const VkPhysicalDeviceShaderClockFeaturesKHR * val)5238 vn_sizeof_VkPhysicalDeviceShaderClockFeaturesKHR_self_partial(const VkPhysicalDeviceShaderClockFeaturesKHR *val)
5239 {
5240 size_t size = 0;
5241 /* skip val->{sType,pNext} */
5242 /* skip val->shaderSubgroupClock */
5243 /* skip val->shaderDeviceClock */
5244 return size;
5245 }
5246
5247 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderClockFeaturesKHR_partial(const VkPhysicalDeviceShaderClockFeaturesKHR * val)5248 vn_sizeof_VkPhysicalDeviceShaderClockFeaturesKHR_partial(const VkPhysicalDeviceShaderClockFeaturesKHR *val)
5249 {
5250 size_t size = 0;
5251
5252 size += vn_sizeof_VkStructureType(&val->sType);
5253 size += vn_sizeof_VkPhysicalDeviceShaderClockFeaturesKHR_pnext_partial(val->pNext);
5254 size += vn_sizeof_VkPhysicalDeviceShaderClockFeaturesKHR_self_partial(val);
5255
5256 return size;
5257 }
5258
5259 static inline void
vn_encode_VkPhysicalDeviceShaderClockFeaturesKHR_pnext_partial(struct vn_cs_encoder * enc,const void * val)5260 vn_encode_VkPhysicalDeviceShaderClockFeaturesKHR_pnext_partial(struct vn_cs_encoder *enc, const void *val)
5261 {
5262 /* no known/supported struct */
5263 vn_encode_simple_pointer(enc, NULL);
5264 }
5265
5266 static inline void
vn_encode_VkPhysicalDeviceShaderClockFeaturesKHR_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderClockFeaturesKHR * val)5267 vn_encode_VkPhysicalDeviceShaderClockFeaturesKHR_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderClockFeaturesKHR *val)
5268 {
5269 /* skip val->{sType,pNext} */
5270 /* skip val->shaderSubgroupClock */
5271 /* skip val->shaderDeviceClock */
5272 }
5273
5274 static inline void
vn_encode_VkPhysicalDeviceShaderClockFeaturesKHR_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderClockFeaturesKHR * val)5275 vn_encode_VkPhysicalDeviceShaderClockFeaturesKHR_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderClockFeaturesKHR *val)
5276 {
5277 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR);
5278 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR });
5279 vn_encode_VkPhysicalDeviceShaderClockFeaturesKHR_pnext_partial(enc, val->pNext);
5280 vn_encode_VkPhysicalDeviceShaderClockFeaturesKHR_self_partial(enc, val);
5281 }
5282
5283 /* struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT chain */
5284
5285 static inline size_t
vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext(const void * val)5286 vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext(const void *val)
5287 {
5288 /* no known/supported struct */
5289 return vn_sizeof_simple_pointer(NULL);
5290 }
5291
5292 static inline size_t
vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)5293 vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
5294 {
5295 size_t size = 0;
5296 /* skip val->{sType,pNext} */
5297 size += vn_sizeof_VkBool32(&val->indexTypeUint8);
5298 return size;
5299 }
5300
5301 static inline size_t
vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)5302 vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
5303 {
5304 size_t size = 0;
5305
5306 size += vn_sizeof_VkStructureType(&val->sType);
5307 size += vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext(val->pNext);
5308 size += vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(val);
5309
5310 return size;
5311 }
5312
5313 static inline void
vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)5314 vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
5315 {
5316 /* no known/supported struct */
5317 vn_encode_simple_pointer(enc, NULL);
5318 }
5319
5320 static inline void
vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)5321 vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
5322 {
5323 /* skip val->{sType,pNext} */
5324 vn_encode_VkBool32(enc, &val->indexTypeUint8);
5325 }
5326
5327 static inline void
vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)5328 vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
5329 {
5330 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT);
5331 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT });
5332 vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext(enc, val->pNext);
5333 vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(enc, val);
5334 }
5335
5336 static inline void
vn_decode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)5337 vn_decode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
5338 {
5339 /* no known/supported struct */
5340 if (vn_decode_simple_pointer(dec))
5341 assert(false);
5342 }
5343
5344 static inline void
vn_decode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)5345 vn_decode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
5346 {
5347 /* skip val->{sType,pNext} */
5348 vn_decode_VkBool32(dec, &val->indexTypeUint8);
5349 }
5350
5351 static inline void
vn_decode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)5352 vn_decode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
5353 {
5354 VkStructureType stype;
5355 vn_decode_VkStructureType(dec, &stype);
5356 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT);
5357
5358 assert(val->sType == stype);
5359 vn_decode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext(dec, val->pNext);
5360 vn_decode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(dec, val);
5361 }
5362
5363 static inline size_t
vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext_partial(const void * val)5364 vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext_partial(const void *val)
5365 {
5366 /* no known/supported struct */
5367 return vn_sizeof_simple_pointer(NULL);
5368 }
5369
5370 static inline size_t
vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self_partial(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)5371 vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self_partial(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
5372 {
5373 size_t size = 0;
5374 /* skip val->{sType,pNext} */
5375 /* skip val->indexTypeUint8 */
5376 return size;
5377 }
5378
5379 static inline size_t
vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_partial(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)5380 vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_partial(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
5381 {
5382 size_t size = 0;
5383
5384 size += vn_sizeof_VkStructureType(&val->sType);
5385 size += vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext_partial(val->pNext);
5386 size += vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self_partial(val);
5387
5388 return size;
5389 }
5390
5391 static inline void
vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)5392 vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
5393 {
5394 /* no known/supported struct */
5395 vn_encode_simple_pointer(enc, NULL);
5396 }
5397
5398 static inline void
vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)5399 vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
5400 {
5401 /* skip val->{sType,pNext} */
5402 /* skip val->indexTypeUint8 */
5403 }
5404
5405 static inline void
vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)5406 vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
5407 {
5408 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT);
5409 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT });
5410 vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext_partial(enc, val->pNext);
5411 vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self_partial(enc, val);
5412 }
5413
5414 /* struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT chain */
5415
5416 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_pnext(const void * val)5417 vn_sizeof_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_pnext(const void *val)
5418 {
5419 /* no known/supported struct */
5420 return vn_sizeof_simple_pointer(NULL);
5421 }
5422
5423 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT * val)5424 vn_sizeof_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *val)
5425 {
5426 size_t size = 0;
5427 /* skip val->{sType,pNext} */
5428 size += vn_sizeof_VkBool32(&val->fragmentShaderSampleInterlock);
5429 size += vn_sizeof_VkBool32(&val->fragmentShaderPixelInterlock);
5430 size += vn_sizeof_VkBool32(&val->fragmentShaderShadingRateInterlock);
5431 return size;
5432 }
5433
5434 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT * val)5435 vn_sizeof_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *val)
5436 {
5437 size_t size = 0;
5438
5439 size += vn_sizeof_VkStructureType(&val->sType);
5440 size += vn_sizeof_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_pnext(val->pNext);
5441 size += vn_sizeof_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self(val);
5442
5443 return size;
5444 }
5445
5446 static inline void
vn_encode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)5447 vn_encode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
5448 {
5449 /* no known/supported struct */
5450 vn_encode_simple_pointer(enc, NULL);
5451 }
5452
5453 static inline void
vn_encode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT * val)5454 vn_encode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *val)
5455 {
5456 /* skip val->{sType,pNext} */
5457 vn_encode_VkBool32(enc, &val->fragmentShaderSampleInterlock);
5458 vn_encode_VkBool32(enc, &val->fragmentShaderPixelInterlock);
5459 vn_encode_VkBool32(enc, &val->fragmentShaderShadingRateInterlock);
5460 }
5461
5462 static inline void
vn_encode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT * val)5463 vn_encode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *val)
5464 {
5465 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT);
5466 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT });
5467 vn_encode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_pnext(enc, val->pNext);
5468 vn_encode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self(enc, val);
5469 }
5470
5471 static inline void
vn_decode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)5472 vn_decode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
5473 {
5474 /* no known/supported struct */
5475 if (vn_decode_simple_pointer(dec))
5476 assert(false);
5477 }
5478
5479 static inline void
vn_decode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT * val)5480 vn_decode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *val)
5481 {
5482 /* skip val->{sType,pNext} */
5483 vn_decode_VkBool32(dec, &val->fragmentShaderSampleInterlock);
5484 vn_decode_VkBool32(dec, &val->fragmentShaderPixelInterlock);
5485 vn_decode_VkBool32(dec, &val->fragmentShaderShadingRateInterlock);
5486 }
5487
5488 static inline void
vn_decode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT * val)5489 vn_decode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *val)
5490 {
5491 VkStructureType stype;
5492 vn_decode_VkStructureType(dec, &stype);
5493 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT);
5494
5495 assert(val->sType == stype);
5496 vn_decode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_pnext(dec, val->pNext);
5497 vn_decode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self(dec, val);
5498 }
5499
5500 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_pnext_partial(const void * val)5501 vn_sizeof_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_pnext_partial(const void *val)
5502 {
5503 /* no known/supported struct */
5504 return vn_sizeof_simple_pointer(NULL);
5505 }
5506
5507 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self_partial(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT * val)5508 vn_sizeof_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self_partial(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *val)
5509 {
5510 size_t size = 0;
5511 /* skip val->{sType,pNext} */
5512 /* skip val->fragmentShaderSampleInterlock */
5513 /* skip val->fragmentShaderPixelInterlock */
5514 /* skip val->fragmentShaderShadingRateInterlock */
5515 return size;
5516 }
5517
5518 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_partial(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT * val)5519 vn_sizeof_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_partial(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *val)
5520 {
5521 size_t size = 0;
5522
5523 size += vn_sizeof_VkStructureType(&val->sType);
5524 size += vn_sizeof_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_pnext_partial(val->pNext);
5525 size += vn_sizeof_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self_partial(val);
5526
5527 return size;
5528 }
5529
5530 static inline void
vn_encode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)5531 vn_encode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
5532 {
5533 /* no known/supported struct */
5534 vn_encode_simple_pointer(enc, NULL);
5535 }
5536
5537 static inline void
vn_encode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT * val)5538 vn_encode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *val)
5539 {
5540 /* skip val->{sType,pNext} */
5541 /* skip val->fragmentShaderSampleInterlock */
5542 /* skip val->fragmentShaderPixelInterlock */
5543 /* skip val->fragmentShaderShadingRateInterlock */
5544 }
5545
5546 static inline void
vn_encode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT * val)5547 vn_encode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *val)
5548 {
5549 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT);
5550 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT });
5551 vn_encode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_pnext_partial(enc, val->pNext);
5552 vn_encode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self_partial(enc, val);
5553 }
5554
5555 /* struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures chain */
5556
5557 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(const void * val)5558 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(const void *val)
5559 {
5560 /* no known/supported struct */
5561 return vn_sizeof_simple_pointer(NULL);
5562 }
5563
5564 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5565 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5566 {
5567 size_t size = 0;
5568 /* skip val->{sType,pNext} */
5569 size += vn_sizeof_VkBool32(&val->separateDepthStencilLayouts);
5570 return size;
5571 }
5572
5573 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5574 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5575 {
5576 size_t size = 0;
5577
5578 size += vn_sizeof_VkStructureType(&val->sType);
5579 size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(val->pNext);
5580 size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(val);
5581
5582 return size;
5583 }
5584
5585 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_encoder * enc,const void * val)5586 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
5587 {
5588 /* no known/supported struct */
5589 vn_encode_simple_pointer(enc, NULL);
5590 }
5591
5592 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5593 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5594 {
5595 /* skip val->{sType,pNext} */
5596 vn_encode_VkBool32(enc, &val->separateDepthStencilLayouts);
5597 }
5598
5599 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5600 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5601 {
5602 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
5603 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES });
5604 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(enc, val->pNext);
5605 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, val);
5606 }
5607
5608 static inline void
vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_decoder * dec,const void * val)5609 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_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_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5617 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5618 {
5619 /* skip val->{sType,pNext} */
5620 vn_decode_VkBool32(dec, &val->separateDepthStencilLayouts);
5621 }
5622
5623 static inline void
vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5624 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5625 {
5626 VkStructureType stype;
5627 vn_decode_VkStructureType(dec, &stype);
5628 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
5629
5630 assert(val->sType == stype);
5631 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(dec, val->pNext);
5632 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(dec, val);
5633 }
5634
5635 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(const void * val)5636 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(const void *val)
5637 {
5638 /* no known/supported struct */
5639 return vn_sizeof_simple_pointer(NULL);
5640 }
5641
5642 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5643 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5644 {
5645 size_t size = 0;
5646 /* skip val->{sType,pNext} */
5647 /* skip val->separateDepthStencilLayouts */
5648 return size;
5649 }
5650
5651 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5652 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5653 {
5654 size_t size = 0;
5655
5656 size += vn_sizeof_VkStructureType(&val->sType);
5657 size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(val->pNext);
5658 size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(val);
5659
5660 return size;
5661 }
5662
5663 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)5664 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
5665 {
5666 /* no known/supported struct */
5667 vn_encode_simple_pointer(enc, NULL);
5668 }
5669
5670 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5671 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5672 {
5673 /* skip val->{sType,pNext} */
5674 /* skip val->separateDepthStencilLayouts */
5675 }
5676
5677 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5678 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5679 {
5680 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
5681 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES });
5682 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(enc, val->pNext);
5683 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(enc, val);
5684 }
5685
5686 /* struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT chain */
5687
5688 static inline size_t
vn_sizeof_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_pnext(const void * val)5689 vn_sizeof_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_pnext(const void *val)
5690 {
5691 /* no known/supported struct */
5692 return vn_sizeof_simple_pointer(NULL);
5693 }
5694
5695 static inline size_t
vn_sizeof_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self(const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT * val)5696 vn_sizeof_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self(const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *val)
5697 {
5698 size_t size = 0;
5699 /* skip val->{sType,pNext} */
5700 size += vn_sizeof_VkBool32(&val->primitiveTopologyListRestart);
5701 size += vn_sizeof_VkBool32(&val->primitiveTopologyPatchListRestart);
5702 return size;
5703 }
5704
5705 static inline size_t
vn_sizeof_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT * val)5706 vn_sizeof_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *val)
5707 {
5708 size_t size = 0;
5709
5710 size += vn_sizeof_VkStructureType(&val->sType);
5711 size += vn_sizeof_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_pnext(val->pNext);
5712 size += vn_sizeof_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self(val);
5713
5714 return size;
5715 }
5716
5717 static inline void
vn_encode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)5718 vn_encode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
5719 {
5720 /* no known/supported struct */
5721 vn_encode_simple_pointer(enc, NULL);
5722 }
5723
5724 static inline void
vn_encode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT * val)5725 vn_encode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *val)
5726 {
5727 /* skip val->{sType,pNext} */
5728 vn_encode_VkBool32(enc, &val->primitiveTopologyListRestart);
5729 vn_encode_VkBool32(enc, &val->primitiveTopologyPatchListRestart);
5730 }
5731
5732 static inline void
vn_encode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT * val)5733 vn_encode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *val)
5734 {
5735 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT);
5736 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT });
5737 vn_encode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_pnext(enc, val->pNext);
5738 vn_encode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self(enc, val);
5739 }
5740
5741 static inline void
vn_decode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)5742 vn_decode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
5743 {
5744 /* no known/supported struct */
5745 if (vn_decode_simple_pointer(dec))
5746 assert(false);
5747 }
5748
5749 static inline void
vn_decode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT * val)5750 vn_decode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *val)
5751 {
5752 /* skip val->{sType,pNext} */
5753 vn_decode_VkBool32(dec, &val->primitiveTopologyListRestart);
5754 vn_decode_VkBool32(dec, &val->primitiveTopologyPatchListRestart);
5755 }
5756
5757 static inline void
vn_decode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT * val)5758 vn_decode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *val)
5759 {
5760 VkStructureType stype;
5761 vn_decode_VkStructureType(dec, &stype);
5762 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT);
5763
5764 assert(val->sType == stype);
5765 vn_decode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_pnext(dec, val->pNext);
5766 vn_decode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self(dec, val);
5767 }
5768
5769 static inline size_t
vn_sizeof_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_pnext_partial(const void * val)5770 vn_sizeof_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_pnext_partial(const void *val)
5771 {
5772 /* no known/supported struct */
5773 return vn_sizeof_simple_pointer(NULL);
5774 }
5775
5776 static inline size_t
vn_sizeof_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self_partial(const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT * val)5777 vn_sizeof_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self_partial(const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *val)
5778 {
5779 size_t size = 0;
5780 /* skip val->{sType,pNext} */
5781 /* skip val->primitiveTopologyListRestart */
5782 /* skip val->primitiveTopologyPatchListRestart */
5783 return size;
5784 }
5785
5786 static inline size_t
vn_sizeof_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_partial(const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT * val)5787 vn_sizeof_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_partial(const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *val)
5788 {
5789 size_t size = 0;
5790
5791 size += vn_sizeof_VkStructureType(&val->sType);
5792 size += vn_sizeof_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_pnext_partial(val->pNext);
5793 size += vn_sizeof_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self_partial(val);
5794
5795 return size;
5796 }
5797
5798 static inline void
vn_encode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)5799 vn_encode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
5800 {
5801 /* no known/supported struct */
5802 vn_encode_simple_pointer(enc, NULL);
5803 }
5804
5805 static inline void
vn_encode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT * val)5806 vn_encode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *val)
5807 {
5808 /* skip val->{sType,pNext} */
5809 /* skip val->primitiveTopologyListRestart */
5810 /* skip val->primitiveTopologyPatchListRestart */
5811 }
5812
5813 static inline void
vn_encode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT * val)5814 vn_encode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *val)
5815 {
5816 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT);
5817 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT });
5818 vn_encode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_pnext_partial(enc, val->pNext);
5819 vn_encode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self_partial(enc, val);
5820 }
5821
5822 /* struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures chain */
5823
5824 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(const void * val)5825 vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(const void *val)
5826 {
5827 /* no known/supported struct */
5828 return vn_sizeof_simple_pointer(NULL);
5829 }
5830
5831 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5832 vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5833 {
5834 size_t size = 0;
5835 /* skip val->{sType,pNext} */
5836 size += vn_sizeof_VkBool32(&val->shaderDemoteToHelperInvocation);
5837 return size;
5838 }
5839
5840 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5841 vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5842 {
5843 size_t size = 0;
5844
5845 size += vn_sizeof_VkStructureType(&val->sType);
5846 size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(val->pNext);
5847 size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(val);
5848
5849 return size;
5850 }
5851
5852 static inline void
vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(struct vn_cs_encoder * enc,const void * val)5853 vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
5854 {
5855 /* no known/supported struct */
5856 vn_encode_simple_pointer(enc, NULL);
5857 }
5858
5859 static inline void
vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5860 vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5861 {
5862 /* skip val->{sType,pNext} */
5863 vn_encode_VkBool32(enc, &val->shaderDemoteToHelperInvocation);
5864 }
5865
5866 static inline void
vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5867 vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5868 {
5869 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES);
5870 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES });
5871 vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(enc, val->pNext);
5872 vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(enc, val);
5873 }
5874
5875 static inline void
vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(struct vn_cs_decoder * dec,const void * val)5876 vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
5877 {
5878 /* no known/supported struct */
5879 if (vn_decode_simple_pointer(dec))
5880 assert(false);
5881 }
5882
5883 static inline void
vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5884 vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5885 {
5886 /* skip val->{sType,pNext} */
5887 vn_decode_VkBool32(dec, &val->shaderDemoteToHelperInvocation);
5888 }
5889
5890 static inline void
vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5891 vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5892 {
5893 VkStructureType stype;
5894 vn_decode_VkStructureType(dec, &stype);
5895 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES);
5896
5897 assert(val->sType == stype);
5898 vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(dec, val->pNext);
5899 vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(dec, val);
5900 }
5901
5902 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext_partial(const void * val)5903 vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext_partial(const void *val)
5904 {
5905 /* no known/supported struct */
5906 return vn_sizeof_simple_pointer(NULL);
5907 }
5908
5909 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5910 vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5911 {
5912 size_t size = 0;
5913 /* skip val->{sType,pNext} */
5914 /* skip val->shaderDemoteToHelperInvocation */
5915 return size;
5916 }
5917
5918 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_partial(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5919 vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_partial(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5920 {
5921 size_t size = 0;
5922
5923 size += vn_sizeof_VkStructureType(&val->sType);
5924 size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext_partial(val->pNext);
5925 size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial(val);
5926
5927 return size;
5928 }
5929
5930 static inline void
vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)5931 vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
5932 {
5933 /* no known/supported struct */
5934 vn_encode_simple_pointer(enc, NULL);
5935 }
5936
5937 static inline void
vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5938 vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5939 {
5940 /* skip val->{sType,pNext} */
5941 /* skip val->shaderDemoteToHelperInvocation */
5942 }
5943
5944 static inline void
vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5945 vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5946 {
5947 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES);
5948 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES });
5949 vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext_partial(enc, val->pNext);
5950 vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial(enc, val);
5951 }
5952
5953 /* struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT chain */
5954
5955 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(const void * val)5956 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(const void *val)
5957 {
5958 /* no known/supported struct */
5959 return vn_sizeof_simple_pointer(NULL);
5960 }
5961
5962 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)5963 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
5964 {
5965 size_t size = 0;
5966 /* skip val->{sType,pNext} */
5967 size += vn_sizeof_VkBool32(&val->texelBufferAlignment);
5968 return size;
5969 }
5970
5971 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)5972 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
5973 {
5974 size_t size = 0;
5975
5976 size += vn_sizeof_VkStructureType(&val->sType);
5977 size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(val->pNext);
5978 size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(val);
5979
5980 return size;
5981 }
5982
5983 static inline void
vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)5984 vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
5985 {
5986 /* no known/supported struct */
5987 vn_encode_simple_pointer(enc, NULL);
5988 }
5989
5990 static inline void
vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)5991 vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
5992 {
5993 /* skip val->{sType,pNext} */
5994 vn_encode_VkBool32(enc, &val->texelBufferAlignment);
5995 }
5996
5997 static inline void
vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)5998 vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
5999 {
6000 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT);
6001 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT });
6002 vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(enc, val->pNext);
6003 vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(enc, val);
6004 }
6005
6006 static inline void
vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)6007 vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
6008 {
6009 /* no known/supported struct */
6010 if (vn_decode_simple_pointer(dec))
6011 assert(false);
6012 }
6013
6014 static inline void
vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)6015 vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
6016 {
6017 /* skip val->{sType,pNext} */
6018 vn_decode_VkBool32(dec, &val->texelBufferAlignment);
6019 }
6020
6021 static inline void
vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)6022 vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
6023 {
6024 VkStructureType stype;
6025 vn_decode_VkStructureType(dec, &stype);
6026 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT);
6027
6028 assert(val->sType == stype);
6029 vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(dec, val->pNext);
6030 vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(dec, val);
6031 }
6032
6033 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext_partial(const void * val)6034 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext_partial(const void *val)
6035 {
6036 /* no known/supported struct */
6037 return vn_sizeof_simple_pointer(NULL);
6038 }
6039
6040 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)6041 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
6042 {
6043 size_t size = 0;
6044 /* skip val->{sType,pNext} */
6045 /* skip val->texelBufferAlignment */
6046 return size;
6047 }
6048
6049 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_partial(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)6050 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_partial(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
6051 {
6052 size_t size = 0;
6053
6054 size += vn_sizeof_VkStructureType(&val->sType);
6055 size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext_partial(val->pNext);
6056 size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial(val);
6057
6058 return size;
6059 }
6060
6061 static inline void
vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)6062 vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6063 {
6064 /* no known/supported struct */
6065 vn_encode_simple_pointer(enc, NULL);
6066 }
6067
6068 static inline void
vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)6069 vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
6070 {
6071 /* skip val->{sType,pNext} */
6072 /* skip val->texelBufferAlignment */
6073 }
6074
6075 static inline void
vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)6076 vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
6077 {
6078 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT);
6079 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT });
6080 vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext_partial(enc, val->pNext);
6081 vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial(enc, val);
6082 }
6083
6084 /* struct VkPhysicalDeviceSubgroupSizeControlFeatures chain */
6085
6086 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(const void * val)6087 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(const void *val)
6088 {
6089 /* no known/supported struct */
6090 return vn_sizeof_simple_pointer(NULL);
6091 }
6092
6093 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self(const VkPhysicalDeviceSubgroupSizeControlFeatures * val)6094 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self(const VkPhysicalDeviceSubgroupSizeControlFeatures *val)
6095 {
6096 size_t size = 0;
6097 /* skip val->{sType,pNext} */
6098 size += vn_sizeof_VkBool32(&val->subgroupSizeControl);
6099 size += vn_sizeof_VkBool32(&val->computeFullSubgroups);
6100 return size;
6101 }
6102
6103 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures(const VkPhysicalDeviceSubgroupSizeControlFeatures * val)6104 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures(const VkPhysicalDeviceSubgroupSizeControlFeatures *val)
6105 {
6106 size_t size = 0;
6107
6108 size += vn_sizeof_VkStructureType(&val->sType);
6109 size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(val->pNext);
6110 size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self(val);
6111
6112 return size;
6113 }
6114
6115 static inline void
vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(struct vn_cs_encoder * enc,const void * val)6116 vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
6117 {
6118 /* no known/supported struct */
6119 vn_encode_simple_pointer(enc, NULL);
6120 }
6121
6122 static inline void
vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupSizeControlFeatures * val)6123 vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupSizeControlFeatures *val)
6124 {
6125 /* skip val->{sType,pNext} */
6126 vn_encode_VkBool32(enc, &val->subgroupSizeControl);
6127 vn_encode_VkBool32(enc, &val->computeFullSubgroups);
6128 }
6129
6130 static inline void
vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupSizeControlFeatures * val)6131 vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupSizeControlFeatures *val)
6132 {
6133 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES);
6134 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES });
6135 vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(enc, val->pNext);
6136 vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(enc, val);
6137 }
6138
6139 static inline void
vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(struct vn_cs_decoder * dec,const void * val)6140 vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
6141 {
6142 /* no known/supported struct */
6143 if (vn_decode_simple_pointer(dec))
6144 assert(false);
6145 }
6146
6147 static inline void
vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSubgroupSizeControlFeatures * val)6148 vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupSizeControlFeatures *val)
6149 {
6150 /* skip val->{sType,pNext} */
6151 vn_decode_VkBool32(dec, &val->subgroupSizeControl);
6152 vn_decode_VkBool32(dec, &val->computeFullSubgroups);
6153 }
6154
6155 static inline void
vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceSubgroupSizeControlFeatures * val)6156 vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupSizeControlFeatures *val)
6157 {
6158 VkStructureType stype;
6159 vn_decode_VkStructureType(dec, &stype);
6160 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES);
6161
6162 assert(val->sType == stype);
6163 vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(dec, val->pNext);
6164 vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(dec, val);
6165 }
6166
6167 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext_partial(const void * val)6168 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext_partial(const void *val)
6169 {
6170 /* no known/supported struct */
6171 return vn_sizeof_simple_pointer(NULL);
6172 }
6173
6174 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial(const VkPhysicalDeviceSubgroupSizeControlFeatures * val)6175 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial(const VkPhysicalDeviceSubgroupSizeControlFeatures *val)
6176 {
6177 size_t size = 0;
6178 /* skip val->{sType,pNext} */
6179 /* skip val->subgroupSizeControl */
6180 /* skip val->computeFullSubgroups */
6181 return size;
6182 }
6183
6184 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_partial(const VkPhysicalDeviceSubgroupSizeControlFeatures * val)6185 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_partial(const VkPhysicalDeviceSubgroupSizeControlFeatures *val)
6186 {
6187 size_t size = 0;
6188
6189 size += vn_sizeof_VkStructureType(&val->sType);
6190 size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext_partial(val->pNext);
6191 size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial(val);
6192
6193 return size;
6194 }
6195
6196 static inline void
vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)6197 vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6198 {
6199 /* no known/supported struct */
6200 vn_encode_simple_pointer(enc, NULL);
6201 }
6202
6203 static inline void
vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupSizeControlFeatures * val)6204 vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupSizeControlFeatures *val)
6205 {
6206 /* skip val->{sType,pNext} */
6207 /* skip val->subgroupSizeControl */
6208 /* skip val->computeFullSubgroups */
6209 }
6210
6211 static inline void
vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupSizeControlFeatures * val)6212 vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupSizeControlFeatures *val)
6213 {
6214 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES);
6215 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES });
6216 vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext_partial(enc, val->pNext);
6217 vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial(enc, val);
6218 }
6219
6220 /* struct VkPhysicalDeviceLineRasterizationFeaturesEXT chain */
6221
6222 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext(const void * val)6223 vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext(const void *val)
6224 {
6225 /* no known/supported struct */
6226 return vn_sizeof_simple_pointer(NULL);
6227 }
6228
6229 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(const VkPhysicalDeviceLineRasterizationFeaturesEXT * val)6230 vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(const VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
6231 {
6232 size_t size = 0;
6233 /* skip val->{sType,pNext} */
6234 size += vn_sizeof_VkBool32(&val->rectangularLines);
6235 size += vn_sizeof_VkBool32(&val->bresenhamLines);
6236 size += vn_sizeof_VkBool32(&val->smoothLines);
6237 size += vn_sizeof_VkBool32(&val->stippledRectangularLines);
6238 size += vn_sizeof_VkBool32(&val->stippledBresenhamLines);
6239 size += vn_sizeof_VkBool32(&val->stippledSmoothLines);
6240 return size;
6241 }
6242
6243 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT(const VkPhysicalDeviceLineRasterizationFeaturesEXT * val)6244 vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT(const VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
6245 {
6246 size_t size = 0;
6247
6248 size += vn_sizeof_VkStructureType(&val->sType);
6249 size += vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext(val->pNext);
6250 size += vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(val);
6251
6252 return size;
6253 }
6254
6255 static inline void
vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)6256 vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
6257 {
6258 /* no known/supported struct */
6259 vn_encode_simple_pointer(enc, NULL);
6260 }
6261
6262 static inline void
vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceLineRasterizationFeaturesEXT * val)6263 vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
6264 {
6265 /* skip val->{sType,pNext} */
6266 vn_encode_VkBool32(enc, &val->rectangularLines);
6267 vn_encode_VkBool32(enc, &val->bresenhamLines);
6268 vn_encode_VkBool32(enc, &val->smoothLines);
6269 vn_encode_VkBool32(enc, &val->stippledRectangularLines);
6270 vn_encode_VkBool32(enc, &val->stippledBresenhamLines);
6271 vn_encode_VkBool32(enc, &val->stippledSmoothLines);
6272 }
6273
6274 static inline void
vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceLineRasterizationFeaturesEXT * val)6275 vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
6276 {
6277 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT);
6278 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT });
6279 vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext(enc, val->pNext);
6280 vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(enc, val);
6281 }
6282
6283 static inline void
vn_decode_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)6284 vn_decode_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
6285 {
6286 /* no known/supported struct */
6287 if (vn_decode_simple_pointer(dec))
6288 assert(false);
6289 }
6290
6291 static inline void
vn_decode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceLineRasterizationFeaturesEXT * val)6292 vn_decode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
6293 {
6294 /* skip val->{sType,pNext} */
6295 vn_decode_VkBool32(dec, &val->rectangularLines);
6296 vn_decode_VkBool32(dec, &val->bresenhamLines);
6297 vn_decode_VkBool32(dec, &val->smoothLines);
6298 vn_decode_VkBool32(dec, &val->stippledRectangularLines);
6299 vn_decode_VkBool32(dec, &val->stippledBresenhamLines);
6300 vn_decode_VkBool32(dec, &val->stippledSmoothLines);
6301 }
6302
6303 static inline void
vn_decode_VkPhysicalDeviceLineRasterizationFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceLineRasterizationFeaturesEXT * val)6304 vn_decode_VkPhysicalDeviceLineRasterizationFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
6305 {
6306 VkStructureType stype;
6307 vn_decode_VkStructureType(dec, &stype);
6308 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT);
6309
6310 assert(val->sType == stype);
6311 vn_decode_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext(dec, val->pNext);
6312 vn_decode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(dec, val);
6313 }
6314
6315 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext_partial(const void * val)6316 vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext_partial(const void *val)
6317 {
6318 /* no known/supported struct */
6319 return vn_sizeof_simple_pointer(NULL);
6320 }
6321
6322 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_self_partial(const VkPhysicalDeviceLineRasterizationFeaturesEXT * val)6323 vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_self_partial(const VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
6324 {
6325 size_t size = 0;
6326 /* skip val->{sType,pNext} */
6327 /* skip val->rectangularLines */
6328 /* skip val->bresenhamLines */
6329 /* skip val->smoothLines */
6330 /* skip val->stippledRectangularLines */
6331 /* skip val->stippledBresenhamLines */
6332 /* skip val->stippledSmoothLines */
6333 return size;
6334 }
6335
6336 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_partial(const VkPhysicalDeviceLineRasterizationFeaturesEXT * val)6337 vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_partial(const VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
6338 {
6339 size_t size = 0;
6340
6341 size += vn_sizeof_VkStructureType(&val->sType);
6342 size += vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext_partial(val->pNext);
6343 size += vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_self_partial(val);
6344
6345 return size;
6346 }
6347
6348 static inline void
vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)6349 vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6350 {
6351 /* no known/supported struct */
6352 vn_encode_simple_pointer(enc, NULL);
6353 }
6354
6355 static inline void
vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceLineRasterizationFeaturesEXT * val)6356 vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
6357 {
6358 /* skip val->{sType,pNext} */
6359 /* skip val->rectangularLines */
6360 /* skip val->bresenhamLines */
6361 /* skip val->smoothLines */
6362 /* skip val->stippledRectangularLines */
6363 /* skip val->stippledBresenhamLines */
6364 /* skip val->stippledSmoothLines */
6365 }
6366
6367 static inline void
vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceLineRasterizationFeaturesEXT * val)6368 vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
6369 {
6370 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT);
6371 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT });
6372 vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext_partial(enc, val->pNext);
6373 vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self_partial(enc, val);
6374 }
6375
6376 /* struct VkPhysicalDevicePipelineCreationCacheControlFeatures chain */
6377
6378 static inline size_t
vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(const void * val)6379 vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(const void *val)
6380 {
6381 /* no known/supported struct */
6382 return vn_sizeof_simple_pointer(NULL);
6383 }
6384
6385 static inline size_t
vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(const VkPhysicalDevicePipelineCreationCacheControlFeatures * val)6386 vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(const VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
6387 {
6388 size_t size = 0;
6389 /* skip val->{sType,pNext} */
6390 size += vn_sizeof_VkBool32(&val->pipelineCreationCacheControl);
6391 return size;
6392 }
6393
6394 static inline size_t
vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures(const VkPhysicalDevicePipelineCreationCacheControlFeatures * val)6395 vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures(const VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
6396 {
6397 size_t size = 0;
6398
6399 size += vn_sizeof_VkStructureType(&val->sType);
6400 size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(val->pNext);
6401 size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(val);
6402
6403 return size;
6404 }
6405
6406 static inline void
vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(struct vn_cs_encoder * enc,const void * val)6407 vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
6408 {
6409 /* no known/supported struct */
6410 vn_encode_simple_pointer(enc, NULL);
6411 }
6412
6413 static inline void
vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDevicePipelineCreationCacheControlFeatures * val)6414 vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
6415 {
6416 /* skip val->{sType,pNext} */
6417 vn_encode_VkBool32(enc, &val->pipelineCreationCacheControl);
6418 }
6419
6420 static inline void
vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures(struct vn_cs_encoder * enc,const VkPhysicalDevicePipelineCreationCacheControlFeatures * val)6421 vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
6422 {
6423 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES);
6424 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES });
6425 vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(enc, val->pNext);
6426 vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(enc, val);
6427 }
6428
6429 static inline void
vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(struct vn_cs_decoder * dec,const void * val)6430 vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
6431 {
6432 /* no known/supported struct */
6433 if (vn_decode_simple_pointer(dec))
6434 assert(false);
6435 }
6436
6437 static inline void
vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDevicePipelineCreationCacheControlFeatures * val)6438 vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
6439 {
6440 /* skip val->{sType,pNext} */
6441 vn_decode_VkBool32(dec, &val->pipelineCreationCacheControl);
6442 }
6443
6444 static inline void
vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures(struct vn_cs_decoder * dec,VkPhysicalDevicePipelineCreationCacheControlFeatures * val)6445 vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures(struct vn_cs_decoder *dec, VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
6446 {
6447 VkStructureType stype;
6448 vn_decode_VkStructureType(dec, &stype);
6449 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES);
6450
6451 assert(val->sType == stype);
6452 vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(dec, val->pNext);
6453 vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(dec, val);
6454 }
6455
6456 static inline size_t
vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext_partial(const void * val)6457 vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext_partial(const void *val)
6458 {
6459 /* no known/supported struct */
6460 return vn_sizeof_simple_pointer(NULL);
6461 }
6462
6463 static inline size_t
vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial(const VkPhysicalDevicePipelineCreationCacheControlFeatures * val)6464 vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial(const VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
6465 {
6466 size_t size = 0;
6467 /* skip val->{sType,pNext} */
6468 /* skip val->pipelineCreationCacheControl */
6469 return size;
6470 }
6471
6472 static inline size_t
vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_partial(const VkPhysicalDevicePipelineCreationCacheControlFeatures * val)6473 vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_partial(const VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
6474 {
6475 size_t size = 0;
6476
6477 size += vn_sizeof_VkStructureType(&val->sType);
6478 size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext_partial(val->pNext);
6479 size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial(val);
6480
6481 return size;
6482 }
6483
6484 static inline void
vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)6485 vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6486 {
6487 /* no known/supported struct */
6488 vn_encode_simple_pointer(enc, NULL);
6489 }
6490
6491 static inline void
vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePipelineCreationCacheControlFeatures * val)6492 vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
6493 {
6494 /* skip val->{sType,pNext} */
6495 /* skip val->pipelineCreationCacheControl */
6496 }
6497
6498 static inline void
vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePipelineCreationCacheControlFeatures * val)6499 vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
6500 {
6501 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES);
6502 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES });
6503 vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext_partial(enc, val->pNext);
6504 vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial(enc, val);
6505 }
6506
6507 /* struct VkPhysicalDeviceVulkan11Features chain */
6508
6509 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext(const void * val)6510 vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext(const void *val)
6511 {
6512 /* no known/supported struct */
6513 return vn_sizeof_simple_pointer(NULL);
6514 }
6515
6516 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_self(const VkPhysicalDeviceVulkan11Features * val)6517 vn_sizeof_VkPhysicalDeviceVulkan11Features_self(const VkPhysicalDeviceVulkan11Features *val)
6518 {
6519 size_t size = 0;
6520 /* skip val->{sType,pNext} */
6521 size += vn_sizeof_VkBool32(&val->storageBuffer16BitAccess);
6522 size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer16BitAccess);
6523 size += vn_sizeof_VkBool32(&val->storagePushConstant16);
6524 size += vn_sizeof_VkBool32(&val->storageInputOutput16);
6525 size += vn_sizeof_VkBool32(&val->multiview);
6526 size += vn_sizeof_VkBool32(&val->multiviewGeometryShader);
6527 size += vn_sizeof_VkBool32(&val->multiviewTessellationShader);
6528 size += vn_sizeof_VkBool32(&val->variablePointersStorageBuffer);
6529 size += vn_sizeof_VkBool32(&val->variablePointers);
6530 size += vn_sizeof_VkBool32(&val->protectedMemory);
6531 size += vn_sizeof_VkBool32(&val->samplerYcbcrConversion);
6532 size += vn_sizeof_VkBool32(&val->shaderDrawParameters);
6533 return size;
6534 }
6535
6536 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features * val)6537 vn_sizeof_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features *val)
6538 {
6539 size_t size = 0;
6540
6541 size += vn_sizeof_VkStructureType(&val->sType);
6542 size += vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext(val->pNext);
6543 size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self(val);
6544
6545 return size;
6546 }
6547
6548 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_encoder * enc,const void * val)6549 vn_encode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_encoder *enc, const void *val)
6550 {
6551 /* no known/supported struct */
6552 vn_encode_simple_pointer(enc, NULL);
6553 }
6554
6555 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Features * val)6556 vn_encode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
6557 {
6558 /* skip val->{sType,pNext} */
6559 vn_encode_VkBool32(enc, &val->storageBuffer16BitAccess);
6560 vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer16BitAccess);
6561 vn_encode_VkBool32(enc, &val->storagePushConstant16);
6562 vn_encode_VkBool32(enc, &val->storageInputOutput16);
6563 vn_encode_VkBool32(enc, &val->multiview);
6564 vn_encode_VkBool32(enc, &val->multiviewGeometryShader);
6565 vn_encode_VkBool32(enc, &val->multiviewTessellationShader);
6566 vn_encode_VkBool32(enc, &val->variablePointersStorageBuffer);
6567 vn_encode_VkBool32(enc, &val->variablePointers);
6568 vn_encode_VkBool32(enc, &val->protectedMemory);
6569 vn_encode_VkBool32(enc, &val->samplerYcbcrConversion);
6570 vn_encode_VkBool32(enc, &val->shaderDrawParameters);
6571 }
6572
6573 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Features * val)6574 vn_encode_VkPhysicalDeviceVulkan11Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
6575 {
6576 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
6577 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES });
6578 vn_encode_VkPhysicalDeviceVulkan11Features_pnext(enc, val->pNext);
6579 vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, val);
6580 }
6581
6582 static inline void
vn_decode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_decoder * dec,const void * val)6583 vn_decode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_decoder *dec, const void *val)
6584 {
6585 /* no known/supported struct */
6586 if (vn_decode_simple_pointer(dec))
6587 assert(false);
6588 }
6589
6590 static inline void
vn_decode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Features * val)6591 vn_decode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Features *val)
6592 {
6593 /* skip val->{sType,pNext} */
6594 vn_decode_VkBool32(dec, &val->storageBuffer16BitAccess);
6595 vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer16BitAccess);
6596 vn_decode_VkBool32(dec, &val->storagePushConstant16);
6597 vn_decode_VkBool32(dec, &val->storageInputOutput16);
6598 vn_decode_VkBool32(dec, &val->multiview);
6599 vn_decode_VkBool32(dec, &val->multiviewGeometryShader);
6600 vn_decode_VkBool32(dec, &val->multiviewTessellationShader);
6601 vn_decode_VkBool32(dec, &val->variablePointersStorageBuffer);
6602 vn_decode_VkBool32(dec, &val->variablePointers);
6603 vn_decode_VkBool32(dec, &val->protectedMemory);
6604 vn_decode_VkBool32(dec, &val->samplerYcbcrConversion);
6605 vn_decode_VkBool32(dec, &val->shaderDrawParameters);
6606 }
6607
6608 static inline void
vn_decode_VkPhysicalDeviceVulkan11Features(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Features * val)6609 vn_decode_VkPhysicalDeviceVulkan11Features(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Features *val)
6610 {
6611 VkStructureType stype;
6612 vn_decode_VkStructureType(dec, &stype);
6613 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
6614
6615 assert(val->sType == stype);
6616 vn_decode_VkPhysicalDeviceVulkan11Features_pnext(dec, val->pNext);
6617 vn_decode_VkPhysicalDeviceVulkan11Features_self(dec, val);
6618 }
6619
6620 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext_partial(const void * val)6621 vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext_partial(const void *val)
6622 {
6623 /* no known/supported struct */
6624 return vn_sizeof_simple_pointer(NULL);
6625 }
6626
6627 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial(const VkPhysicalDeviceVulkan11Features * val)6628 vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial(const VkPhysicalDeviceVulkan11Features *val)
6629 {
6630 size_t size = 0;
6631 /* skip val->{sType,pNext} */
6632 /* skip val->storageBuffer16BitAccess */
6633 /* skip val->uniformAndStorageBuffer16BitAccess */
6634 /* skip val->storagePushConstant16 */
6635 /* skip val->storageInputOutput16 */
6636 /* skip val->multiview */
6637 /* skip val->multiviewGeometryShader */
6638 /* skip val->multiviewTessellationShader */
6639 /* skip val->variablePointersStorageBuffer */
6640 /* skip val->variablePointers */
6641 /* skip val->protectedMemory */
6642 /* skip val->samplerYcbcrConversion */
6643 /* skip val->shaderDrawParameters */
6644 return size;
6645 }
6646
6647 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_partial(const VkPhysicalDeviceVulkan11Features * val)6648 vn_sizeof_VkPhysicalDeviceVulkan11Features_partial(const VkPhysicalDeviceVulkan11Features *val)
6649 {
6650 size_t size = 0;
6651
6652 size += vn_sizeof_VkStructureType(&val->sType);
6653 size += vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext_partial(val->pNext);
6654 size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial(val);
6655
6656 return size;
6657 }
6658
6659 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)6660 vn_encode_VkPhysicalDeviceVulkan11Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6661 {
6662 /* no known/supported struct */
6663 vn_encode_simple_pointer(enc, NULL);
6664 }
6665
6666 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Features * val)6667 vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
6668 {
6669 /* skip val->{sType,pNext} */
6670 /* skip val->storageBuffer16BitAccess */
6671 /* skip val->uniformAndStorageBuffer16BitAccess */
6672 /* skip val->storagePushConstant16 */
6673 /* skip val->storageInputOutput16 */
6674 /* skip val->multiview */
6675 /* skip val->multiviewGeometryShader */
6676 /* skip val->multiviewTessellationShader */
6677 /* skip val->variablePointersStorageBuffer */
6678 /* skip val->variablePointers */
6679 /* skip val->protectedMemory */
6680 /* skip val->samplerYcbcrConversion */
6681 /* skip val->shaderDrawParameters */
6682 }
6683
6684 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Features * val)6685 vn_encode_VkPhysicalDeviceVulkan11Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
6686 {
6687 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
6688 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES });
6689 vn_encode_VkPhysicalDeviceVulkan11Features_pnext_partial(enc, val->pNext);
6690 vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(enc, val);
6691 }
6692
6693 /* struct VkPhysicalDeviceVulkan12Features chain */
6694
6695 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext(const void * val)6696 vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext(const void *val)
6697 {
6698 /* no known/supported struct */
6699 return vn_sizeof_simple_pointer(NULL);
6700 }
6701
6702 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_self(const VkPhysicalDeviceVulkan12Features * val)6703 vn_sizeof_VkPhysicalDeviceVulkan12Features_self(const VkPhysicalDeviceVulkan12Features *val)
6704 {
6705 size_t size = 0;
6706 /* skip val->{sType,pNext} */
6707 size += vn_sizeof_VkBool32(&val->samplerMirrorClampToEdge);
6708 size += vn_sizeof_VkBool32(&val->drawIndirectCount);
6709 size += vn_sizeof_VkBool32(&val->storageBuffer8BitAccess);
6710 size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer8BitAccess);
6711 size += vn_sizeof_VkBool32(&val->storagePushConstant8);
6712 size += vn_sizeof_VkBool32(&val->shaderBufferInt64Atomics);
6713 size += vn_sizeof_VkBool32(&val->shaderSharedInt64Atomics);
6714 size += vn_sizeof_VkBool32(&val->shaderFloat16);
6715 size += vn_sizeof_VkBool32(&val->shaderInt8);
6716 size += vn_sizeof_VkBool32(&val->descriptorIndexing);
6717 size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayDynamicIndexing);
6718 size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayDynamicIndexing);
6719 size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayDynamicIndexing);
6720 size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexing);
6721 size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexing);
6722 size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexing);
6723 size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexing);
6724 size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexing);
6725 size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayNonUniformIndexing);
6726 size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayNonUniformIndexing);
6727 size += vn_sizeof_VkBool32(&val->descriptorBindingUniformBufferUpdateAfterBind);
6728 size += vn_sizeof_VkBool32(&val->descriptorBindingSampledImageUpdateAfterBind);
6729 size += vn_sizeof_VkBool32(&val->descriptorBindingStorageImageUpdateAfterBind);
6730 size += vn_sizeof_VkBool32(&val->descriptorBindingStorageBufferUpdateAfterBind);
6731 size += vn_sizeof_VkBool32(&val->descriptorBindingUniformTexelBufferUpdateAfterBind);
6732 size += vn_sizeof_VkBool32(&val->descriptorBindingStorageTexelBufferUpdateAfterBind);
6733 size += vn_sizeof_VkBool32(&val->descriptorBindingUpdateUnusedWhilePending);
6734 size += vn_sizeof_VkBool32(&val->descriptorBindingPartiallyBound);
6735 size += vn_sizeof_VkBool32(&val->descriptorBindingVariableDescriptorCount);
6736 size += vn_sizeof_VkBool32(&val->runtimeDescriptorArray);
6737 size += vn_sizeof_VkBool32(&val->samplerFilterMinmax);
6738 size += vn_sizeof_VkBool32(&val->scalarBlockLayout);
6739 size += vn_sizeof_VkBool32(&val->imagelessFramebuffer);
6740 size += vn_sizeof_VkBool32(&val->uniformBufferStandardLayout);
6741 size += vn_sizeof_VkBool32(&val->shaderSubgroupExtendedTypes);
6742 size += vn_sizeof_VkBool32(&val->separateDepthStencilLayouts);
6743 size += vn_sizeof_VkBool32(&val->hostQueryReset);
6744 size += vn_sizeof_VkBool32(&val->timelineSemaphore);
6745 size += vn_sizeof_VkBool32(&val->bufferDeviceAddress);
6746 size += vn_sizeof_VkBool32(&val->bufferDeviceAddressCaptureReplay);
6747 size += vn_sizeof_VkBool32(&val->bufferDeviceAddressMultiDevice);
6748 size += vn_sizeof_VkBool32(&val->vulkanMemoryModel);
6749 size += vn_sizeof_VkBool32(&val->vulkanMemoryModelDeviceScope);
6750 size += vn_sizeof_VkBool32(&val->vulkanMemoryModelAvailabilityVisibilityChains);
6751 size += vn_sizeof_VkBool32(&val->shaderOutputViewportIndex);
6752 size += vn_sizeof_VkBool32(&val->shaderOutputLayer);
6753 size += vn_sizeof_VkBool32(&val->subgroupBroadcastDynamicId);
6754 return size;
6755 }
6756
6757 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features * val)6758 vn_sizeof_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features *val)
6759 {
6760 size_t size = 0;
6761
6762 size += vn_sizeof_VkStructureType(&val->sType);
6763 size += vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext(val->pNext);
6764 size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self(val);
6765
6766 return size;
6767 }
6768
6769 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_encoder * enc,const void * val)6770 vn_encode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_encoder *enc, const void *val)
6771 {
6772 /* no known/supported struct */
6773 vn_encode_simple_pointer(enc, NULL);
6774 }
6775
6776 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Features * val)6777 vn_encode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
6778 {
6779 /* skip val->{sType,pNext} */
6780 vn_encode_VkBool32(enc, &val->samplerMirrorClampToEdge);
6781 vn_encode_VkBool32(enc, &val->drawIndirectCount);
6782 vn_encode_VkBool32(enc, &val->storageBuffer8BitAccess);
6783 vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer8BitAccess);
6784 vn_encode_VkBool32(enc, &val->storagePushConstant8);
6785 vn_encode_VkBool32(enc, &val->shaderBufferInt64Atomics);
6786 vn_encode_VkBool32(enc, &val->shaderSharedInt64Atomics);
6787 vn_encode_VkBool32(enc, &val->shaderFloat16);
6788 vn_encode_VkBool32(enc, &val->shaderInt8);
6789 vn_encode_VkBool32(enc, &val->descriptorIndexing);
6790 vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayDynamicIndexing);
6791 vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayDynamicIndexing);
6792 vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayDynamicIndexing);
6793 vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayNonUniformIndexing);
6794 vn_encode_VkBool32(enc, &val->shaderSampledImageArrayNonUniformIndexing);
6795 vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayNonUniformIndexing);
6796 vn_encode_VkBool32(enc, &val->shaderStorageImageArrayNonUniformIndexing);
6797 vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayNonUniformIndexing);
6798 vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
6799 vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
6800 vn_encode_VkBool32(enc, &val->descriptorBindingUniformBufferUpdateAfterBind);
6801 vn_encode_VkBool32(enc, &val->descriptorBindingSampledImageUpdateAfterBind);
6802 vn_encode_VkBool32(enc, &val->descriptorBindingStorageImageUpdateAfterBind);
6803 vn_encode_VkBool32(enc, &val->descriptorBindingStorageBufferUpdateAfterBind);
6804 vn_encode_VkBool32(enc, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
6805 vn_encode_VkBool32(enc, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
6806 vn_encode_VkBool32(enc, &val->descriptorBindingUpdateUnusedWhilePending);
6807 vn_encode_VkBool32(enc, &val->descriptorBindingPartiallyBound);
6808 vn_encode_VkBool32(enc, &val->descriptorBindingVariableDescriptorCount);
6809 vn_encode_VkBool32(enc, &val->runtimeDescriptorArray);
6810 vn_encode_VkBool32(enc, &val->samplerFilterMinmax);
6811 vn_encode_VkBool32(enc, &val->scalarBlockLayout);
6812 vn_encode_VkBool32(enc, &val->imagelessFramebuffer);
6813 vn_encode_VkBool32(enc, &val->uniformBufferStandardLayout);
6814 vn_encode_VkBool32(enc, &val->shaderSubgroupExtendedTypes);
6815 vn_encode_VkBool32(enc, &val->separateDepthStencilLayouts);
6816 vn_encode_VkBool32(enc, &val->hostQueryReset);
6817 vn_encode_VkBool32(enc, &val->timelineSemaphore);
6818 vn_encode_VkBool32(enc, &val->bufferDeviceAddress);
6819 vn_encode_VkBool32(enc, &val->bufferDeviceAddressCaptureReplay);
6820 vn_encode_VkBool32(enc, &val->bufferDeviceAddressMultiDevice);
6821 vn_encode_VkBool32(enc, &val->vulkanMemoryModel);
6822 vn_encode_VkBool32(enc, &val->vulkanMemoryModelDeviceScope);
6823 vn_encode_VkBool32(enc, &val->vulkanMemoryModelAvailabilityVisibilityChains);
6824 vn_encode_VkBool32(enc, &val->shaderOutputViewportIndex);
6825 vn_encode_VkBool32(enc, &val->shaderOutputLayer);
6826 vn_encode_VkBool32(enc, &val->subgroupBroadcastDynamicId);
6827 }
6828
6829 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Features * val)6830 vn_encode_VkPhysicalDeviceVulkan12Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
6831 {
6832 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
6833 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES });
6834 vn_encode_VkPhysicalDeviceVulkan12Features_pnext(enc, val->pNext);
6835 vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, val);
6836 }
6837
6838 static inline void
vn_decode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_decoder * dec,const void * val)6839 vn_decode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_decoder *dec, const void *val)
6840 {
6841 /* no known/supported struct */
6842 if (vn_decode_simple_pointer(dec))
6843 assert(false);
6844 }
6845
6846 static inline void
vn_decode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Features * val)6847 vn_decode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Features *val)
6848 {
6849 /* skip val->{sType,pNext} */
6850 vn_decode_VkBool32(dec, &val->samplerMirrorClampToEdge);
6851 vn_decode_VkBool32(dec, &val->drawIndirectCount);
6852 vn_decode_VkBool32(dec, &val->storageBuffer8BitAccess);
6853 vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer8BitAccess);
6854 vn_decode_VkBool32(dec, &val->storagePushConstant8);
6855 vn_decode_VkBool32(dec, &val->shaderBufferInt64Atomics);
6856 vn_decode_VkBool32(dec, &val->shaderSharedInt64Atomics);
6857 vn_decode_VkBool32(dec, &val->shaderFloat16);
6858 vn_decode_VkBool32(dec, &val->shaderInt8);
6859 vn_decode_VkBool32(dec, &val->descriptorIndexing);
6860 vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayDynamicIndexing);
6861 vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayDynamicIndexing);
6862 vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayDynamicIndexing);
6863 vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexing);
6864 vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexing);
6865 vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexing);
6866 vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexing);
6867 vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexing);
6868 vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
6869 vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
6870 vn_decode_VkBool32(dec, &val->descriptorBindingUniformBufferUpdateAfterBind);
6871 vn_decode_VkBool32(dec, &val->descriptorBindingSampledImageUpdateAfterBind);
6872 vn_decode_VkBool32(dec, &val->descriptorBindingStorageImageUpdateAfterBind);
6873 vn_decode_VkBool32(dec, &val->descriptorBindingStorageBufferUpdateAfterBind);
6874 vn_decode_VkBool32(dec, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
6875 vn_decode_VkBool32(dec, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
6876 vn_decode_VkBool32(dec, &val->descriptorBindingUpdateUnusedWhilePending);
6877 vn_decode_VkBool32(dec, &val->descriptorBindingPartiallyBound);
6878 vn_decode_VkBool32(dec, &val->descriptorBindingVariableDescriptorCount);
6879 vn_decode_VkBool32(dec, &val->runtimeDescriptorArray);
6880 vn_decode_VkBool32(dec, &val->samplerFilterMinmax);
6881 vn_decode_VkBool32(dec, &val->scalarBlockLayout);
6882 vn_decode_VkBool32(dec, &val->imagelessFramebuffer);
6883 vn_decode_VkBool32(dec, &val->uniformBufferStandardLayout);
6884 vn_decode_VkBool32(dec, &val->shaderSubgroupExtendedTypes);
6885 vn_decode_VkBool32(dec, &val->separateDepthStencilLayouts);
6886 vn_decode_VkBool32(dec, &val->hostQueryReset);
6887 vn_decode_VkBool32(dec, &val->timelineSemaphore);
6888 vn_decode_VkBool32(dec, &val->bufferDeviceAddress);
6889 vn_decode_VkBool32(dec, &val->bufferDeviceAddressCaptureReplay);
6890 vn_decode_VkBool32(dec, &val->bufferDeviceAddressMultiDevice);
6891 vn_decode_VkBool32(dec, &val->vulkanMemoryModel);
6892 vn_decode_VkBool32(dec, &val->vulkanMemoryModelDeviceScope);
6893 vn_decode_VkBool32(dec, &val->vulkanMemoryModelAvailabilityVisibilityChains);
6894 vn_decode_VkBool32(dec, &val->shaderOutputViewportIndex);
6895 vn_decode_VkBool32(dec, &val->shaderOutputLayer);
6896 vn_decode_VkBool32(dec, &val->subgroupBroadcastDynamicId);
6897 }
6898
6899 static inline void
vn_decode_VkPhysicalDeviceVulkan12Features(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Features * val)6900 vn_decode_VkPhysicalDeviceVulkan12Features(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Features *val)
6901 {
6902 VkStructureType stype;
6903 vn_decode_VkStructureType(dec, &stype);
6904 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
6905
6906 assert(val->sType == stype);
6907 vn_decode_VkPhysicalDeviceVulkan12Features_pnext(dec, val->pNext);
6908 vn_decode_VkPhysicalDeviceVulkan12Features_self(dec, val);
6909 }
6910
6911 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext_partial(const void * val)6912 vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext_partial(const void *val)
6913 {
6914 /* no known/supported struct */
6915 return vn_sizeof_simple_pointer(NULL);
6916 }
6917
6918 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial(const VkPhysicalDeviceVulkan12Features * val)6919 vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial(const VkPhysicalDeviceVulkan12Features *val)
6920 {
6921 size_t size = 0;
6922 /* skip val->{sType,pNext} */
6923 /* skip val->samplerMirrorClampToEdge */
6924 /* skip val->drawIndirectCount */
6925 /* skip val->storageBuffer8BitAccess */
6926 /* skip val->uniformAndStorageBuffer8BitAccess */
6927 /* skip val->storagePushConstant8 */
6928 /* skip val->shaderBufferInt64Atomics */
6929 /* skip val->shaderSharedInt64Atomics */
6930 /* skip val->shaderFloat16 */
6931 /* skip val->shaderInt8 */
6932 /* skip val->descriptorIndexing */
6933 /* skip val->shaderInputAttachmentArrayDynamicIndexing */
6934 /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
6935 /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
6936 /* skip val->shaderUniformBufferArrayNonUniformIndexing */
6937 /* skip val->shaderSampledImageArrayNonUniformIndexing */
6938 /* skip val->shaderStorageBufferArrayNonUniformIndexing */
6939 /* skip val->shaderStorageImageArrayNonUniformIndexing */
6940 /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
6941 /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
6942 /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
6943 /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
6944 /* skip val->descriptorBindingSampledImageUpdateAfterBind */
6945 /* skip val->descriptorBindingStorageImageUpdateAfterBind */
6946 /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
6947 /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
6948 /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
6949 /* skip val->descriptorBindingUpdateUnusedWhilePending */
6950 /* skip val->descriptorBindingPartiallyBound */
6951 /* skip val->descriptorBindingVariableDescriptorCount */
6952 /* skip val->runtimeDescriptorArray */
6953 /* skip val->samplerFilterMinmax */
6954 /* skip val->scalarBlockLayout */
6955 /* skip val->imagelessFramebuffer */
6956 /* skip val->uniformBufferStandardLayout */
6957 /* skip val->shaderSubgroupExtendedTypes */
6958 /* skip val->separateDepthStencilLayouts */
6959 /* skip val->hostQueryReset */
6960 /* skip val->timelineSemaphore */
6961 /* skip val->bufferDeviceAddress */
6962 /* skip val->bufferDeviceAddressCaptureReplay */
6963 /* skip val->bufferDeviceAddressMultiDevice */
6964 /* skip val->vulkanMemoryModel */
6965 /* skip val->vulkanMemoryModelDeviceScope */
6966 /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
6967 /* skip val->shaderOutputViewportIndex */
6968 /* skip val->shaderOutputLayer */
6969 /* skip val->subgroupBroadcastDynamicId */
6970 return size;
6971 }
6972
6973 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_partial(const VkPhysicalDeviceVulkan12Features * val)6974 vn_sizeof_VkPhysicalDeviceVulkan12Features_partial(const VkPhysicalDeviceVulkan12Features *val)
6975 {
6976 size_t size = 0;
6977
6978 size += vn_sizeof_VkStructureType(&val->sType);
6979 size += vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext_partial(val->pNext);
6980 size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial(val);
6981
6982 return size;
6983 }
6984
6985 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)6986 vn_encode_VkPhysicalDeviceVulkan12Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6987 {
6988 /* no known/supported struct */
6989 vn_encode_simple_pointer(enc, NULL);
6990 }
6991
6992 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Features * val)6993 vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
6994 {
6995 /* skip val->{sType,pNext} */
6996 /* skip val->samplerMirrorClampToEdge */
6997 /* skip val->drawIndirectCount */
6998 /* skip val->storageBuffer8BitAccess */
6999 /* skip val->uniformAndStorageBuffer8BitAccess */
7000 /* skip val->storagePushConstant8 */
7001 /* skip val->shaderBufferInt64Atomics */
7002 /* skip val->shaderSharedInt64Atomics */
7003 /* skip val->shaderFloat16 */
7004 /* skip val->shaderInt8 */
7005 /* skip val->descriptorIndexing */
7006 /* skip val->shaderInputAttachmentArrayDynamicIndexing */
7007 /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
7008 /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
7009 /* skip val->shaderUniformBufferArrayNonUniformIndexing */
7010 /* skip val->shaderSampledImageArrayNonUniformIndexing */
7011 /* skip val->shaderStorageBufferArrayNonUniformIndexing */
7012 /* skip val->shaderStorageImageArrayNonUniformIndexing */
7013 /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
7014 /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
7015 /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
7016 /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
7017 /* skip val->descriptorBindingSampledImageUpdateAfterBind */
7018 /* skip val->descriptorBindingStorageImageUpdateAfterBind */
7019 /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
7020 /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
7021 /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
7022 /* skip val->descriptorBindingUpdateUnusedWhilePending */
7023 /* skip val->descriptorBindingPartiallyBound */
7024 /* skip val->descriptorBindingVariableDescriptorCount */
7025 /* skip val->runtimeDescriptorArray */
7026 /* skip val->samplerFilterMinmax */
7027 /* skip val->scalarBlockLayout */
7028 /* skip val->imagelessFramebuffer */
7029 /* skip val->uniformBufferStandardLayout */
7030 /* skip val->shaderSubgroupExtendedTypes */
7031 /* skip val->separateDepthStencilLayouts */
7032 /* skip val->hostQueryReset */
7033 /* skip val->timelineSemaphore */
7034 /* skip val->bufferDeviceAddress */
7035 /* skip val->bufferDeviceAddressCaptureReplay */
7036 /* skip val->bufferDeviceAddressMultiDevice */
7037 /* skip val->vulkanMemoryModel */
7038 /* skip val->vulkanMemoryModelDeviceScope */
7039 /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
7040 /* skip val->shaderOutputViewportIndex */
7041 /* skip val->shaderOutputLayer */
7042 /* skip val->subgroupBroadcastDynamicId */
7043 }
7044
7045 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Features * val)7046 vn_encode_VkPhysicalDeviceVulkan12Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
7047 {
7048 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
7049 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES });
7050 vn_encode_VkPhysicalDeviceVulkan12Features_pnext_partial(enc, val->pNext);
7051 vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(enc, val);
7052 }
7053
7054 /* struct VkPhysicalDeviceVulkan13Features chain */
7055
7056 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Features_pnext(const void * val)7057 vn_sizeof_VkPhysicalDeviceVulkan13Features_pnext(const void *val)
7058 {
7059 /* no known/supported struct */
7060 return vn_sizeof_simple_pointer(NULL);
7061 }
7062
7063 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Features_self(const VkPhysicalDeviceVulkan13Features * val)7064 vn_sizeof_VkPhysicalDeviceVulkan13Features_self(const VkPhysicalDeviceVulkan13Features *val)
7065 {
7066 size_t size = 0;
7067 /* skip val->{sType,pNext} */
7068 size += vn_sizeof_VkBool32(&val->robustImageAccess);
7069 size += vn_sizeof_VkBool32(&val->inlineUniformBlock);
7070 size += vn_sizeof_VkBool32(&val->descriptorBindingInlineUniformBlockUpdateAfterBind);
7071 size += vn_sizeof_VkBool32(&val->pipelineCreationCacheControl);
7072 size += vn_sizeof_VkBool32(&val->privateData);
7073 size += vn_sizeof_VkBool32(&val->shaderDemoteToHelperInvocation);
7074 size += vn_sizeof_VkBool32(&val->shaderTerminateInvocation);
7075 size += vn_sizeof_VkBool32(&val->subgroupSizeControl);
7076 size += vn_sizeof_VkBool32(&val->computeFullSubgroups);
7077 size += vn_sizeof_VkBool32(&val->synchronization2);
7078 size += vn_sizeof_VkBool32(&val->textureCompressionASTC_HDR);
7079 size += vn_sizeof_VkBool32(&val->shaderZeroInitializeWorkgroupMemory);
7080 size += vn_sizeof_VkBool32(&val->dynamicRendering);
7081 size += vn_sizeof_VkBool32(&val->shaderIntegerDotProduct);
7082 size += vn_sizeof_VkBool32(&val->maintenance4);
7083 return size;
7084 }
7085
7086 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Features(const VkPhysicalDeviceVulkan13Features * val)7087 vn_sizeof_VkPhysicalDeviceVulkan13Features(const VkPhysicalDeviceVulkan13Features *val)
7088 {
7089 size_t size = 0;
7090
7091 size += vn_sizeof_VkStructureType(&val->sType);
7092 size += vn_sizeof_VkPhysicalDeviceVulkan13Features_pnext(val->pNext);
7093 size += vn_sizeof_VkPhysicalDeviceVulkan13Features_self(val);
7094
7095 return size;
7096 }
7097
7098 static inline void
vn_encode_VkPhysicalDeviceVulkan13Features_pnext(struct vn_cs_encoder * enc,const void * val)7099 vn_encode_VkPhysicalDeviceVulkan13Features_pnext(struct vn_cs_encoder *enc, const void *val)
7100 {
7101 /* no known/supported struct */
7102 vn_encode_simple_pointer(enc, NULL);
7103 }
7104
7105 static inline void
vn_encode_VkPhysicalDeviceVulkan13Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan13Features * val)7106 vn_encode_VkPhysicalDeviceVulkan13Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan13Features *val)
7107 {
7108 /* skip val->{sType,pNext} */
7109 vn_encode_VkBool32(enc, &val->robustImageAccess);
7110 vn_encode_VkBool32(enc, &val->inlineUniformBlock);
7111 vn_encode_VkBool32(enc, &val->descriptorBindingInlineUniformBlockUpdateAfterBind);
7112 vn_encode_VkBool32(enc, &val->pipelineCreationCacheControl);
7113 vn_encode_VkBool32(enc, &val->privateData);
7114 vn_encode_VkBool32(enc, &val->shaderDemoteToHelperInvocation);
7115 vn_encode_VkBool32(enc, &val->shaderTerminateInvocation);
7116 vn_encode_VkBool32(enc, &val->subgroupSizeControl);
7117 vn_encode_VkBool32(enc, &val->computeFullSubgroups);
7118 vn_encode_VkBool32(enc, &val->synchronization2);
7119 vn_encode_VkBool32(enc, &val->textureCompressionASTC_HDR);
7120 vn_encode_VkBool32(enc, &val->shaderZeroInitializeWorkgroupMemory);
7121 vn_encode_VkBool32(enc, &val->dynamicRendering);
7122 vn_encode_VkBool32(enc, &val->shaderIntegerDotProduct);
7123 vn_encode_VkBool32(enc, &val->maintenance4);
7124 }
7125
7126 static inline void
vn_encode_VkPhysicalDeviceVulkan13Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan13Features * val)7127 vn_encode_VkPhysicalDeviceVulkan13Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan13Features *val)
7128 {
7129 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES);
7130 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES });
7131 vn_encode_VkPhysicalDeviceVulkan13Features_pnext(enc, val->pNext);
7132 vn_encode_VkPhysicalDeviceVulkan13Features_self(enc, val);
7133 }
7134
7135 static inline void
vn_decode_VkPhysicalDeviceVulkan13Features_pnext(struct vn_cs_decoder * dec,const void * val)7136 vn_decode_VkPhysicalDeviceVulkan13Features_pnext(struct vn_cs_decoder *dec, const void *val)
7137 {
7138 /* no known/supported struct */
7139 if (vn_decode_simple_pointer(dec))
7140 assert(false);
7141 }
7142
7143 static inline void
vn_decode_VkPhysicalDeviceVulkan13Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan13Features * val)7144 vn_decode_VkPhysicalDeviceVulkan13Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan13Features *val)
7145 {
7146 /* skip val->{sType,pNext} */
7147 vn_decode_VkBool32(dec, &val->robustImageAccess);
7148 vn_decode_VkBool32(dec, &val->inlineUniformBlock);
7149 vn_decode_VkBool32(dec, &val->descriptorBindingInlineUniformBlockUpdateAfterBind);
7150 vn_decode_VkBool32(dec, &val->pipelineCreationCacheControl);
7151 vn_decode_VkBool32(dec, &val->privateData);
7152 vn_decode_VkBool32(dec, &val->shaderDemoteToHelperInvocation);
7153 vn_decode_VkBool32(dec, &val->shaderTerminateInvocation);
7154 vn_decode_VkBool32(dec, &val->subgroupSizeControl);
7155 vn_decode_VkBool32(dec, &val->computeFullSubgroups);
7156 vn_decode_VkBool32(dec, &val->synchronization2);
7157 vn_decode_VkBool32(dec, &val->textureCompressionASTC_HDR);
7158 vn_decode_VkBool32(dec, &val->shaderZeroInitializeWorkgroupMemory);
7159 vn_decode_VkBool32(dec, &val->dynamicRendering);
7160 vn_decode_VkBool32(dec, &val->shaderIntegerDotProduct);
7161 vn_decode_VkBool32(dec, &val->maintenance4);
7162 }
7163
7164 static inline void
vn_decode_VkPhysicalDeviceVulkan13Features(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan13Features * val)7165 vn_decode_VkPhysicalDeviceVulkan13Features(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan13Features *val)
7166 {
7167 VkStructureType stype;
7168 vn_decode_VkStructureType(dec, &stype);
7169 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES);
7170
7171 assert(val->sType == stype);
7172 vn_decode_VkPhysicalDeviceVulkan13Features_pnext(dec, val->pNext);
7173 vn_decode_VkPhysicalDeviceVulkan13Features_self(dec, val);
7174 }
7175
7176 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Features_pnext_partial(const void * val)7177 vn_sizeof_VkPhysicalDeviceVulkan13Features_pnext_partial(const void *val)
7178 {
7179 /* no known/supported struct */
7180 return vn_sizeof_simple_pointer(NULL);
7181 }
7182
7183 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Features_self_partial(const VkPhysicalDeviceVulkan13Features * val)7184 vn_sizeof_VkPhysicalDeviceVulkan13Features_self_partial(const VkPhysicalDeviceVulkan13Features *val)
7185 {
7186 size_t size = 0;
7187 /* skip val->{sType,pNext} */
7188 /* skip val->robustImageAccess */
7189 /* skip val->inlineUniformBlock */
7190 /* skip val->descriptorBindingInlineUniformBlockUpdateAfterBind */
7191 /* skip val->pipelineCreationCacheControl */
7192 /* skip val->privateData */
7193 /* skip val->shaderDemoteToHelperInvocation */
7194 /* skip val->shaderTerminateInvocation */
7195 /* skip val->subgroupSizeControl */
7196 /* skip val->computeFullSubgroups */
7197 /* skip val->synchronization2 */
7198 /* skip val->textureCompressionASTC_HDR */
7199 /* skip val->shaderZeroInitializeWorkgroupMemory */
7200 /* skip val->dynamicRendering */
7201 /* skip val->shaderIntegerDotProduct */
7202 /* skip val->maintenance4 */
7203 return size;
7204 }
7205
7206 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Features_partial(const VkPhysicalDeviceVulkan13Features * val)7207 vn_sizeof_VkPhysicalDeviceVulkan13Features_partial(const VkPhysicalDeviceVulkan13Features *val)
7208 {
7209 size_t size = 0;
7210
7211 size += vn_sizeof_VkStructureType(&val->sType);
7212 size += vn_sizeof_VkPhysicalDeviceVulkan13Features_pnext_partial(val->pNext);
7213 size += vn_sizeof_VkPhysicalDeviceVulkan13Features_self_partial(val);
7214
7215 return size;
7216 }
7217
7218 static inline void
vn_encode_VkPhysicalDeviceVulkan13Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)7219 vn_encode_VkPhysicalDeviceVulkan13Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7220 {
7221 /* no known/supported struct */
7222 vn_encode_simple_pointer(enc, NULL);
7223 }
7224
7225 static inline void
vn_encode_VkPhysicalDeviceVulkan13Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan13Features * val)7226 vn_encode_VkPhysicalDeviceVulkan13Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan13Features *val)
7227 {
7228 /* skip val->{sType,pNext} */
7229 /* skip val->robustImageAccess */
7230 /* skip val->inlineUniformBlock */
7231 /* skip val->descriptorBindingInlineUniformBlockUpdateAfterBind */
7232 /* skip val->pipelineCreationCacheControl */
7233 /* skip val->privateData */
7234 /* skip val->shaderDemoteToHelperInvocation */
7235 /* skip val->shaderTerminateInvocation */
7236 /* skip val->subgroupSizeControl */
7237 /* skip val->computeFullSubgroups */
7238 /* skip val->synchronization2 */
7239 /* skip val->textureCompressionASTC_HDR */
7240 /* skip val->shaderZeroInitializeWorkgroupMemory */
7241 /* skip val->dynamicRendering */
7242 /* skip val->shaderIntegerDotProduct */
7243 /* skip val->maintenance4 */
7244 }
7245
7246 static inline void
vn_encode_VkPhysicalDeviceVulkan13Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan13Features * val)7247 vn_encode_VkPhysicalDeviceVulkan13Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan13Features *val)
7248 {
7249 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES);
7250 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES });
7251 vn_encode_VkPhysicalDeviceVulkan13Features_pnext_partial(enc, val->pNext);
7252 vn_encode_VkPhysicalDeviceVulkan13Features_self_partial(enc, val);
7253 }
7254
7255 /* struct VkPhysicalDeviceCustomBorderColorFeaturesEXT chain */
7256
7257 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext(const void * val)7258 vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext(const void *val)
7259 {
7260 /* no known/supported struct */
7261 return vn_sizeof_simple_pointer(NULL);
7262 }
7263
7264 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(const VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)7265 vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(const VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
7266 {
7267 size_t size = 0;
7268 /* skip val->{sType,pNext} */
7269 size += vn_sizeof_VkBool32(&val->customBorderColors);
7270 size += vn_sizeof_VkBool32(&val->customBorderColorWithoutFormat);
7271 return size;
7272 }
7273
7274 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)7275 vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
7276 {
7277 size_t size = 0;
7278
7279 size += vn_sizeof_VkStructureType(&val->sType);
7280 size += vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext(val->pNext);
7281 size += vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(val);
7282
7283 return size;
7284 }
7285
7286 static inline void
vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)7287 vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
7288 {
7289 /* no known/supported struct */
7290 vn_encode_simple_pointer(enc, NULL);
7291 }
7292
7293 static inline void
vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)7294 vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
7295 {
7296 /* skip val->{sType,pNext} */
7297 vn_encode_VkBool32(enc, &val->customBorderColors);
7298 vn_encode_VkBool32(enc, &val->customBorderColorWithoutFormat);
7299 }
7300
7301 static inline void
vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)7302 vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
7303 {
7304 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT);
7305 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT });
7306 vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext(enc, val->pNext);
7307 vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(enc, val);
7308 }
7309
7310 static inline void
vn_decode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)7311 vn_decode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
7312 {
7313 /* no known/supported struct */
7314 if (vn_decode_simple_pointer(dec))
7315 assert(false);
7316 }
7317
7318 static inline void
vn_decode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)7319 vn_decode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
7320 {
7321 /* skip val->{sType,pNext} */
7322 vn_decode_VkBool32(dec, &val->customBorderColors);
7323 vn_decode_VkBool32(dec, &val->customBorderColorWithoutFormat);
7324 }
7325
7326 static inline void
vn_decode_VkPhysicalDeviceCustomBorderColorFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)7327 vn_decode_VkPhysicalDeviceCustomBorderColorFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
7328 {
7329 VkStructureType stype;
7330 vn_decode_VkStructureType(dec, &stype);
7331 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT);
7332
7333 assert(val->sType == stype);
7334 vn_decode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext(dec, val->pNext);
7335 vn_decode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(dec, val);
7336 }
7337
7338 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext_partial(const void * val)7339 vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext_partial(const void *val)
7340 {
7341 /* no known/supported struct */
7342 return vn_sizeof_simple_pointer(NULL);
7343 }
7344
7345 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self_partial(const VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)7346 vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self_partial(const VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
7347 {
7348 size_t size = 0;
7349 /* skip val->{sType,pNext} */
7350 /* skip val->customBorderColors */
7351 /* skip val->customBorderColorWithoutFormat */
7352 return size;
7353 }
7354
7355 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_partial(const VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)7356 vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_partial(const VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
7357 {
7358 size_t size = 0;
7359
7360 size += vn_sizeof_VkStructureType(&val->sType);
7361 size += vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext_partial(val->pNext);
7362 size += vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self_partial(val);
7363
7364 return size;
7365 }
7366
7367 static inline void
vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)7368 vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7369 {
7370 /* no known/supported struct */
7371 vn_encode_simple_pointer(enc, NULL);
7372 }
7373
7374 static inline void
vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)7375 vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
7376 {
7377 /* skip val->{sType,pNext} */
7378 /* skip val->customBorderColors */
7379 /* skip val->customBorderColorWithoutFormat */
7380 }
7381
7382 static inline void
vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)7383 vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
7384 {
7385 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT);
7386 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT });
7387 vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext_partial(enc, val->pNext);
7388 vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self_partial(enc, val);
7389 }
7390
7391 /* struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT chain */
7392
7393 static inline size_t
vn_sizeof_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_pnext(const void * val)7394 vn_sizeof_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_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_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT * val)7401 vn_sizeof_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *val)
7402 {
7403 size_t size = 0;
7404 /* skip val->{sType,pNext} */
7405 size += vn_sizeof_VkBool32(&val->borderColorSwizzle);
7406 size += vn_sizeof_VkBool32(&val->borderColorSwizzleFromImage);
7407 return size;
7408 }
7409
7410 static inline size_t
vn_sizeof_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT * val)7411 vn_sizeof_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *val)
7412 {
7413 size_t size = 0;
7414
7415 size += vn_sizeof_VkStructureType(&val->sType);
7416 size += vn_sizeof_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_pnext(val->pNext);
7417 size += vn_sizeof_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self(val);
7418
7419 return size;
7420 }
7421
7422 static inline void
vn_encode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)7423 vn_encode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_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_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT * val)7430 vn_encode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *val)
7431 {
7432 /* skip val->{sType,pNext} */
7433 vn_encode_VkBool32(enc, &val->borderColorSwizzle);
7434 vn_encode_VkBool32(enc, &val->borderColorSwizzleFromImage);
7435 }
7436
7437 static inline void
vn_encode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT * val)7438 vn_encode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *val)
7439 {
7440 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT);
7441 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT });
7442 vn_encode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_pnext(enc, val->pNext);
7443 vn_encode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self(enc, val);
7444 }
7445
7446 static inline void
vn_decode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)7447 vn_decode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_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_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceBorderColorSwizzleFeaturesEXT * val)7455 vn_decode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *val)
7456 {
7457 /* skip val->{sType,pNext} */
7458 vn_decode_VkBool32(dec, &val->borderColorSwizzle);
7459 vn_decode_VkBool32(dec, &val->borderColorSwizzleFromImage);
7460 }
7461
7462 static inline void
vn_decode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceBorderColorSwizzleFeaturesEXT * val)7463 vn_decode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *val)
7464 {
7465 VkStructureType stype;
7466 vn_decode_VkStructureType(dec, &stype);
7467 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT);
7468
7469 assert(val->sType == stype);
7470 vn_decode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_pnext(dec, val->pNext);
7471 vn_decode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self(dec, val);
7472 }
7473
7474 static inline size_t
vn_sizeof_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_pnext_partial(const void * val)7475 vn_sizeof_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_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_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self_partial(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT * val)7482 vn_sizeof_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self_partial(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *val)
7483 {
7484 size_t size = 0;
7485 /* skip val->{sType,pNext} */
7486 /* skip val->borderColorSwizzle */
7487 /* skip val->borderColorSwizzleFromImage */
7488 return size;
7489 }
7490
7491 static inline size_t
vn_sizeof_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_partial(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT * val)7492 vn_sizeof_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_partial(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *val)
7493 {
7494 size_t size = 0;
7495
7496 size += vn_sizeof_VkStructureType(&val->sType);
7497 size += vn_sizeof_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_pnext_partial(val->pNext);
7498 size += vn_sizeof_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self_partial(val);
7499
7500 return size;
7501 }
7502
7503 static inline void
vn_encode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)7504 vn_encode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_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_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT * val)7511 vn_encode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *val)
7512 {
7513 /* skip val->{sType,pNext} */
7514 /* skip val->borderColorSwizzle */
7515 /* skip val->borderColorSwizzleFromImage */
7516 }
7517
7518 static inline void
vn_encode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT * val)7519 vn_encode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *val)
7520 {
7521 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT);
7522 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT });
7523 vn_encode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_pnext_partial(enc, val->pNext);
7524 vn_encode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self_partial(enc, val);
7525 }
7526
7527 /* struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT chain */
7528
7529 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(const void * val)7530 vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_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_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)7537 vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
7538 {
7539 size_t size = 0;
7540 /* skip val->{sType,pNext} */
7541 size += vn_sizeof_VkBool32(&val->extendedDynamicState);
7542 return size;
7543 }
7544
7545 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)7546 vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
7547 {
7548 size_t size = 0;
7549
7550 size += vn_sizeof_VkStructureType(&val->sType);
7551 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(val->pNext);
7552 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(val);
7553
7554 return size;
7555 }
7556
7557 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)7558 vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_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_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)7565 vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
7566 {
7567 /* skip val->{sType,pNext} */
7568 vn_encode_VkBool32(enc, &val->extendedDynamicState);
7569 }
7570
7571 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)7572 vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
7573 {
7574 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT);
7575 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT });
7576 vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(enc, val->pNext);
7577 vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(enc, val);
7578 }
7579
7580 static inline void
vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)7581 vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_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_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)7589 vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
7590 {
7591 /* skip val->{sType,pNext} */
7592 vn_decode_VkBool32(dec, &val->extendedDynamicState);
7593 }
7594
7595 static inline void
vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)7596 vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
7597 {
7598 VkStructureType stype;
7599 vn_decode_VkStructureType(dec, &stype);
7600 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT);
7601
7602 assert(val->sType == stype);
7603 vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(dec, val->pNext);
7604 vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(dec, val);
7605 }
7606
7607 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext_partial(const void * val)7608 vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_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_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)7615 vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
7616 {
7617 size_t size = 0;
7618 /* skip val->{sType,pNext} */
7619 /* skip val->extendedDynamicState */
7620 return size;
7621 }
7622
7623 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_partial(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)7624 vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_partial(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
7625 {
7626 size_t size = 0;
7627
7628 size += vn_sizeof_VkStructureType(&val->sType);
7629 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext_partial(val->pNext);
7630 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial(val);
7631
7632 return size;
7633 }
7634
7635 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)7636 vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_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_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)7643 vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
7644 {
7645 /* skip val->{sType,pNext} */
7646 /* skip val->extendedDynamicState */
7647 }
7648
7649 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)7650 vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
7651 {
7652 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT);
7653 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT });
7654 vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext_partial(enc, val->pNext);
7655 vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial(enc, val);
7656 }
7657
7658 /* struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT chain */
7659
7660 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(const void * val)7661 vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_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_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)7668 vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
7669 {
7670 size_t size = 0;
7671 /* skip val->{sType,pNext} */
7672 size += vn_sizeof_VkBool32(&val->extendedDynamicState2);
7673 size += vn_sizeof_VkBool32(&val->extendedDynamicState2LogicOp);
7674 size += vn_sizeof_VkBool32(&val->extendedDynamicState2PatchControlPoints);
7675 return size;
7676 }
7677
7678 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)7679 vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
7680 {
7681 size_t size = 0;
7682
7683 size += vn_sizeof_VkStructureType(&val->sType);
7684 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(val->pNext);
7685 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(val);
7686
7687 return size;
7688 }
7689
7690 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)7691 vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
7692 {
7693 /* no known/supported struct */
7694 vn_encode_simple_pointer(enc, NULL);
7695 }
7696
7697 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)7698 vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
7699 {
7700 /* skip val->{sType,pNext} */
7701 vn_encode_VkBool32(enc, &val->extendedDynamicState2);
7702 vn_encode_VkBool32(enc, &val->extendedDynamicState2LogicOp);
7703 vn_encode_VkBool32(enc, &val->extendedDynamicState2PatchControlPoints);
7704 }
7705
7706 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)7707 vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
7708 {
7709 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT);
7710 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT });
7711 vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(enc, val->pNext);
7712 vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(enc, val);
7713 }
7714
7715 static inline void
vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)7716 vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
7717 {
7718 /* no known/supported struct */
7719 if (vn_decode_simple_pointer(dec))
7720 assert(false);
7721 }
7722
7723 static inline void
vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)7724 vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
7725 {
7726 /* skip val->{sType,pNext} */
7727 vn_decode_VkBool32(dec, &val->extendedDynamicState2);
7728 vn_decode_VkBool32(dec, &val->extendedDynamicState2LogicOp);
7729 vn_decode_VkBool32(dec, &val->extendedDynamicState2PatchControlPoints);
7730 }
7731
7732 static inline void
vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)7733 vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
7734 {
7735 VkStructureType stype;
7736 vn_decode_VkStructureType(dec, &stype);
7737 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT);
7738
7739 assert(val->sType == stype);
7740 vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(dec, val->pNext);
7741 vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(dec, val);
7742 }
7743
7744 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext_partial(const void * val)7745 vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext_partial(const void *val)
7746 {
7747 /* no known/supported struct */
7748 return vn_sizeof_simple_pointer(NULL);
7749 }
7750
7751 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)7752 vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
7753 {
7754 size_t size = 0;
7755 /* skip val->{sType,pNext} */
7756 /* skip val->extendedDynamicState2 */
7757 /* skip val->extendedDynamicState2LogicOp */
7758 /* skip val->extendedDynamicState2PatchControlPoints */
7759 return size;
7760 }
7761
7762 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_partial(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)7763 vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_partial(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
7764 {
7765 size_t size = 0;
7766
7767 size += vn_sizeof_VkStructureType(&val->sType);
7768 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext_partial(val->pNext);
7769 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial(val);
7770
7771 return size;
7772 }
7773
7774 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)7775 vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7776 {
7777 /* no known/supported struct */
7778 vn_encode_simple_pointer(enc, NULL);
7779 }
7780
7781 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)7782 vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
7783 {
7784 /* skip val->{sType,pNext} */
7785 /* skip val->extendedDynamicState2 */
7786 /* skip val->extendedDynamicState2LogicOp */
7787 /* skip val->extendedDynamicState2PatchControlPoints */
7788 }
7789
7790 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)7791 vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
7792 {
7793 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT);
7794 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT });
7795 vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext_partial(enc, val->pNext);
7796 vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial(enc, val);
7797 }
7798
7799 /* struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT chain */
7800
7801 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_pnext(const void * val)7802 vn_sizeof_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_pnext(const void *val)
7803 {
7804 /* no known/supported struct */
7805 return vn_sizeof_simple_pointer(NULL);
7806 }
7807
7808 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self(const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT * val)7809 vn_sizeof_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self(const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *val)
7810 {
7811 size_t size = 0;
7812 /* skip val->{sType,pNext} */
7813 size += vn_sizeof_VkBool32(&val->extendedDynamicState3TessellationDomainOrigin);
7814 size += vn_sizeof_VkBool32(&val->extendedDynamicState3DepthClampEnable);
7815 size += vn_sizeof_VkBool32(&val->extendedDynamicState3PolygonMode);
7816 size += vn_sizeof_VkBool32(&val->extendedDynamicState3RasterizationSamples);
7817 size += vn_sizeof_VkBool32(&val->extendedDynamicState3SampleMask);
7818 size += vn_sizeof_VkBool32(&val->extendedDynamicState3AlphaToCoverageEnable);
7819 size += vn_sizeof_VkBool32(&val->extendedDynamicState3AlphaToOneEnable);
7820 size += vn_sizeof_VkBool32(&val->extendedDynamicState3LogicOpEnable);
7821 size += vn_sizeof_VkBool32(&val->extendedDynamicState3ColorBlendEnable);
7822 size += vn_sizeof_VkBool32(&val->extendedDynamicState3ColorBlendEquation);
7823 size += vn_sizeof_VkBool32(&val->extendedDynamicState3ColorWriteMask);
7824 size += vn_sizeof_VkBool32(&val->extendedDynamicState3RasterizationStream);
7825 size += vn_sizeof_VkBool32(&val->extendedDynamicState3ConservativeRasterizationMode);
7826 size += vn_sizeof_VkBool32(&val->extendedDynamicState3ExtraPrimitiveOverestimationSize);
7827 size += vn_sizeof_VkBool32(&val->extendedDynamicState3DepthClipEnable);
7828 size += vn_sizeof_VkBool32(&val->extendedDynamicState3SampleLocationsEnable);
7829 size += vn_sizeof_VkBool32(&val->extendedDynamicState3ColorBlendAdvanced);
7830 size += vn_sizeof_VkBool32(&val->extendedDynamicState3ProvokingVertexMode);
7831 size += vn_sizeof_VkBool32(&val->extendedDynamicState3LineRasterizationMode);
7832 size += vn_sizeof_VkBool32(&val->extendedDynamicState3LineStippleEnable);
7833 size += vn_sizeof_VkBool32(&val->extendedDynamicState3DepthClipNegativeOneToOne);
7834 size += vn_sizeof_VkBool32(&val->extendedDynamicState3ViewportWScalingEnable);
7835 size += vn_sizeof_VkBool32(&val->extendedDynamicState3ViewportSwizzle);
7836 size += vn_sizeof_VkBool32(&val->extendedDynamicState3CoverageToColorEnable);
7837 size += vn_sizeof_VkBool32(&val->extendedDynamicState3CoverageToColorLocation);
7838 size += vn_sizeof_VkBool32(&val->extendedDynamicState3CoverageModulationMode);
7839 size += vn_sizeof_VkBool32(&val->extendedDynamicState3CoverageModulationTableEnable);
7840 size += vn_sizeof_VkBool32(&val->extendedDynamicState3CoverageModulationTable);
7841 size += vn_sizeof_VkBool32(&val->extendedDynamicState3CoverageReductionMode);
7842 size += vn_sizeof_VkBool32(&val->extendedDynamicState3RepresentativeFragmentTestEnable);
7843 size += vn_sizeof_VkBool32(&val->extendedDynamicState3ShadingRateImageEnable);
7844 return size;
7845 }
7846
7847 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT * val)7848 vn_sizeof_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *val)
7849 {
7850 size_t size = 0;
7851
7852 size += vn_sizeof_VkStructureType(&val->sType);
7853 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_pnext(val->pNext);
7854 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self(val);
7855
7856 return size;
7857 }
7858
7859 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)7860 vn_encode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
7861 {
7862 /* no known/supported struct */
7863 vn_encode_simple_pointer(enc, NULL);
7864 }
7865
7866 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT * val)7867 vn_encode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *val)
7868 {
7869 /* skip val->{sType,pNext} */
7870 vn_encode_VkBool32(enc, &val->extendedDynamicState3TessellationDomainOrigin);
7871 vn_encode_VkBool32(enc, &val->extendedDynamicState3DepthClampEnable);
7872 vn_encode_VkBool32(enc, &val->extendedDynamicState3PolygonMode);
7873 vn_encode_VkBool32(enc, &val->extendedDynamicState3RasterizationSamples);
7874 vn_encode_VkBool32(enc, &val->extendedDynamicState3SampleMask);
7875 vn_encode_VkBool32(enc, &val->extendedDynamicState3AlphaToCoverageEnable);
7876 vn_encode_VkBool32(enc, &val->extendedDynamicState3AlphaToOneEnable);
7877 vn_encode_VkBool32(enc, &val->extendedDynamicState3LogicOpEnable);
7878 vn_encode_VkBool32(enc, &val->extendedDynamicState3ColorBlendEnable);
7879 vn_encode_VkBool32(enc, &val->extendedDynamicState3ColorBlendEquation);
7880 vn_encode_VkBool32(enc, &val->extendedDynamicState3ColorWriteMask);
7881 vn_encode_VkBool32(enc, &val->extendedDynamicState3RasterizationStream);
7882 vn_encode_VkBool32(enc, &val->extendedDynamicState3ConservativeRasterizationMode);
7883 vn_encode_VkBool32(enc, &val->extendedDynamicState3ExtraPrimitiveOverestimationSize);
7884 vn_encode_VkBool32(enc, &val->extendedDynamicState3DepthClipEnable);
7885 vn_encode_VkBool32(enc, &val->extendedDynamicState3SampleLocationsEnable);
7886 vn_encode_VkBool32(enc, &val->extendedDynamicState3ColorBlendAdvanced);
7887 vn_encode_VkBool32(enc, &val->extendedDynamicState3ProvokingVertexMode);
7888 vn_encode_VkBool32(enc, &val->extendedDynamicState3LineRasterizationMode);
7889 vn_encode_VkBool32(enc, &val->extendedDynamicState3LineStippleEnable);
7890 vn_encode_VkBool32(enc, &val->extendedDynamicState3DepthClipNegativeOneToOne);
7891 vn_encode_VkBool32(enc, &val->extendedDynamicState3ViewportWScalingEnable);
7892 vn_encode_VkBool32(enc, &val->extendedDynamicState3ViewportSwizzle);
7893 vn_encode_VkBool32(enc, &val->extendedDynamicState3CoverageToColorEnable);
7894 vn_encode_VkBool32(enc, &val->extendedDynamicState3CoverageToColorLocation);
7895 vn_encode_VkBool32(enc, &val->extendedDynamicState3CoverageModulationMode);
7896 vn_encode_VkBool32(enc, &val->extendedDynamicState3CoverageModulationTableEnable);
7897 vn_encode_VkBool32(enc, &val->extendedDynamicState3CoverageModulationTable);
7898 vn_encode_VkBool32(enc, &val->extendedDynamicState3CoverageReductionMode);
7899 vn_encode_VkBool32(enc, &val->extendedDynamicState3RepresentativeFragmentTestEnable);
7900 vn_encode_VkBool32(enc, &val->extendedDynamicState3ShadingRateImageEnable);
7901 }
7902
7903 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT * val)7904 vn_encode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *val)
7905 {
7906 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT);
7907 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT });
7908 vn_encode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_pnext(enc, val->pNext);
7909 vn_encode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self(enc, val);
7910 }
7911
7912 static inline void
vn_decode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)7913 vn_decode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
7914 {
7915 /* no known/supported struct */
7916 if (vn_decode_simple_pointer(dec))
7917 assert(false);
7918 }
7919
7920 static inline void
vn_decode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceExtendedDynamicState3FeaturesEXT * val)7921 vn_decode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *val)
7922 {
7923 /* skip val->{sType,pNext} */
7924 vn_decode_VkBool32(dec, &val->extendedDynamicState3TessellationDomainOrigin);
7925 vn_decode_VkBool32(dec, &val->extendedDynamicState3DepthClampEnable);
7926 vn_decode_VkBool32(dec, &val->extendedDynamicState3PolygonMode);
7927 vn_decode_VkBool32(dec, &val->extendedDynamicState3RasterizationSamples);
7928 vn_decode_VkBool32(dec, &val->extendedDynamicState3SampleMask);
7929 vn_decode_VkBool32(dec, &val->extendedDynamicState3AlphaToCoverageEnable);
7930 vn_decode_VkBool32(dec, &val->extendedDynamicState3AlphaToOneEnable);
7931 vn_decode_VkBool32(dec, &val->extendedDynamicState3LogicOpEnable);
7932 vn_decode_VkBool32(dec, &val->extendedDynamicState3ColorBlendEnable);
7933 vn_decode_VkBool32(dec, &val->extendedDynamicState3ColorBlendEquation);
7934 vn_decode_VkBool32(dec, &val->extendedDynamicState3ColorWriteMask);
7935 vn_decode_VkBool32(dec, &val->extendedDynamicState3RasterizationStream);
7936 vn_decode_VkBool32(dec, &val->extendedDynamicState3ConservativeRasterizationMode);
7937 vn_decode_VkBool32(dec, &val->extendedDynamicState3ExtraPrimitiveOverestimationSize);
7938 vn_decode_VkBool32(dec, &val->extendedDynamicState3DepthClipEnable);
7939 vn_decode_VkBool32(dec, &val->extendedDynamicState3SampleLocationsEnable);
7940 vn_decode_VkBool32(dec, &val->extendedDynamicState3ColorBlendAdvanced);
7941 vn_decode_VkBool32(dec, &val->extendedDynamicState3ProvokingVertexMode);
7942 vn_decode_VkBool32(dec, &val->extendedDynamicState3LineRasterizationMode);
7943 vn_decode_VkBool32(dec, &val->extendedDynamicState3LineStippleEnable);
7944 vn_decode_VkBool32(dec, &val->extendedDynamicState3DepthClipNegativeOneToOne);
7945 vn_decode_VkBool32(dec, &val->extendedDynamicState3ViewportWScalingEnable);
7946 vn_decode_VkBool32(dec, &val->extendedDynamicState3ViewportSwizzle);
7947 vn_decode_VkBool32(dec, &val->extendedDynamicState3CoverageToColorEnable);
7948 vn_decode_VkBool32(dec, &val->extendedDynamicState3CoverageToColorLocation);
7949 vn_decode_VkBool32(dec, &val->extendedDynamicState3CoverageModulationMode);
7950 vn_decode_VkBool32(dec, &val->extendedDynamicState3CoverageModulationTableEnable);
7951 vn_decode_VkBool32(dec, &val->extendedDynamicState3CoverageModulationTable);
7952 vn_decode_VkBool32(dec, &val->extendedDynamicState3CoverageReductionMode);
7953 vn_decode_VkBool32(dec, &val->extendedDynamicState3RepresentativeFragmentTestEnable);
7954 vn_decode_VkBool32(dec, &val->extendedDynamicState3ShadingRateImageEnable);
7955 }
7956
7957 static inline void
vn_decode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceExtendedDynamicState3FeaturesEXT * val)7958 vn_decode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *val)
7959 {
7960 VkStructureType stype;
7961 vn_decode_VkStructureType(dec, &stype);
7962 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT);
7963
7964 assert(val->sType == stype);
7965 vn_decode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_pnext(dec, val->pNext);
7966 vn_decode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self(dec, val);
7967 }
7968
7969 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_pnext_partial(const void * val)7970 vn_sizeof_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_pnext_partial(const void *val)
7971 {
7972 /* no known/supported struct */
7973 return vn_sizeof_simple_pointer(NULL);
7974 }
7975
7976 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self_partial(const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT * val)7977 vn_sizeof_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self_partial(const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *val)
7978 {
7979 size_t size = 0;
7980 /* skip val->{sType,pNext} */
7981 /* skip val->extendedDynamicState3TessellationDomainOrigin */
7982 /* skip val->extendedDynamicState3DepthClampEnable */
7983 /* skip val->extendedDynamicState3PolygonMode */
7984 /* skip val->extendedDynamicState3RasterizationSamples */
7985 /* skip val->extendedDynamicState3SampleMask */
7986 /* skip val->extendedDynamicState3AlphaToCoverageEnable */
7987 /* skip val->extendedDynamicState3AlphaToOneEnable */
7988 /* skip val->extendedDynamicState3LogicOpEnable */
7989 /* skip val->extendedDynamicState3ColorBlendEnable */
7990 /* skip val->extendedDynamicState3ColorBlendEquation */
7991 /* skip val->extendedDynamicState3ColorWriteMask */
7992 /* skip val->extendedDynamicState3RasterizationStream */
7993 /* skip val->extendedDynamicState3ConservativeRasterizationMode */
7994 /* skip val->extendedDynamicState3ExtraPrimitiveOverestimationSize */
7995 /* skip val->extendedDynamicState3DepthClipEnable */
7996 /* skip val->extendedDynamicState3SampleLocationsEnable */
7997 /* skip val->extendedDynamicState3ColorBlendAdvanced */
7998 /* skip val->extendedDynamicState3ProvokingVertexMode */
7999 /* skip val->extendedDynamicState3LineRasterizationMode */
8000 /* skip val->extendedDynamicState3LineStippleEnable */
8001 /* skip val->extendedDynamicState3DepthClipNegativeOneToOne */
8002 /* skip val->extendedDynamicState3ViewportWScalingEnable */
8003 /* skip val->extendedDynamicState3ViewportSwizzle */
8004 /* skip val->extendedDynamicState3CoverageToColorEnable */
8005 /* skip val->extendedDynamicState3CoverageToColorLocation */
8006 /* skip val->extendedDynamicState3CoverageModulationMode */
8007 /* skip val->extendedDynamicState3CoverageModulationTableEnable */
8008 /* skip val->extendedDynamicState3CoverageModulationTable */
8009 /* skip val->extendedDynamicState3CoverageReductionMode */
8010 /* skip val->extendedDynamicState3RepresentativeFragmentTestEnable */
8011 /* skip val->extendedDynamicState3ShadingRateImageEnable */
8012 return size;
8013 }
8014
8015 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_partial(const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT * val)8016 vn_sizeof_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_partial(const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *val)
8017 {
8018 size_t size = 0;
8019
8020 size += vn_sizeof_VkStructureType(&val->sType);
8021 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_pnext_partial(val->pNext);
8022 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self_partial(val);
8023
8024 return size;
8025 }
8026
8027 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)8028 vn_encode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
8029 {
8030 /* no known/supported struct */
8031 vn_encode_simple_pointer(enc, NULL);
8032 }
8033
8034 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT * val)8035 vn_encode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *val)
8036 {
8037 /* skip val->{sType,pNext} */
8038 /* skip val->extendedDynamicState3TessellationDomainOrigin */
8039 /* skip val->extendedDynamicState3DepthClampEnable */
8040 /* skip val->extendedDynamicState3PolygonMode */
8041 /* skip val->extendedDynamicState3RasterizationSamples */
8042 /* skip val->extendedDynamicState3SampleMask */
8043 /* skip val->extendedDynamicState3AlphaToCoverageEnable */
8044 /* skip val->extendedDynamicState3AlphaToOneEnable */
8045 /* skip val->extendedDynamicState3LogicOpEnable */
8046 /* skip val->extendedDynamicState3ColorBlendEnable */
8047 /* skip val->extendedDynamicState3ColorBlendEquation */
8048 /* skip val->extendedDynamicState3ColorWriteMask */
8049 /* skip val->extendedDynamicState3RasterizationStream */
8050 /* skip val->extendedDynamicState3ConservativeRasterizationMode */
8051 /* skip val->extendedDynamicState3ExtraPrimitiveOverestimationSize */
8052 /* skip val->extendedDynamicState3DepthClipEnable */
8053 /* skip val->extendedDynamicState3SampleLocationsEnable */
8054 /* skip val->extendedDynamicState3ColorBlendAdvanced */
8055 /* skip val->extendedDynamicState3ProvokingVertexMode */
8056 /* skip val->extendedDynamicState3LineRasterizationMode */
8057 /* skip val->extendedDynamicState3LineStippleEnable */
8058 /* skip val->extendedDynamicState3DepthClipNegativeOneToOne */
8059 /* skip val->extendedDynamicState3ViewportWScalingEnable */
8060 /* skip val->extendedDynamicState3ViewportSwizzle */
8061 /* skip val->extendedDynamicState3CoverageToColorEnable */
8062 /* skip val->extendedDynamicState3CoverageToColorLocation */
8063 /* skip val->extendedDynamicState3CoverageModulationMode */
8064 /* skip val->extendedDynamicState3CoverageModulationTableEnable */
8065 /* skip val->extendedDynamicState3CoverageModulationTable */
8066 /* skip val->extendedDynamicState3CoverageReductionMode */
8067 /* skip val->extendedDynamicState3RepresentativeFragmentTestEnable */
8068 /* skip val->extendedDynamicState3ShadingRateImageEnable */
8069 }
8070
8071 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT * val)8072 vn_encode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *val)
8073 {
8074 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT);
8075 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT });
8076 vn_encode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_pnext_partial(enc, val->pNext);
8077 vn_encode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self_partial(enc, val);
8078 }
8079
8080 /* struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures chain */
8081
8082 static inline size_t
vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(const void * val)8083 vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(const void *val)
8084 {
8085 /* no known/supported struct */
8086 return vn_sizeof_simple_pointer(NULL);
8087 }
8088
8089 static inline size_t
vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)8090 vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
8091 {
8092 size_t size = 0;
8093 /* skip val->{sType,pNext} */
8094 size += vn_sizeof_VkBool32(&val->shaderZeroInitializeWorkgroupMemory);
8095 return size;
8096 }
8097
8098 static inline size_t
vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)8099 vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
8100 {
8101 size_t size = 0;
8102
8103 size += vn_sizeof_VkStructureType(&val->sType);
8104 size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(val->pNext);
8105 size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(val);
8106
8107 return size;
8108 }
8109
8110 static inline void
vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(struct vn_cs_encoder * enc,const void * val)8111 vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
8112 {
8113 /* no known/supported struct */
8114 vn_encode_simple_pointer(enc, NULL);
8115 }
8116
8117 static inline void
vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)8118 vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
8119 {
8120 /* skip val->{sType,pNext} */
8121 vn_encode_VkBool32(enc, &val->shaderZeroInitializeWorkgroupMemory);
8122 }
8123
8124 static inline void
vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)8125 vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
8126 {
8127 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES);
8128 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES });
8129 vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(enc, val->pNext);
8130 vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(enc, val);
8131 }
8132
8133 static inline void
vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(struct vn_cs_decoder * dec,const void * val)8134 vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
8135 {
8136 /* no known/supported struct */
8137 if (vn_decode_simple_pointer(dec))
8138 assert(false);
8139 }
8140
8141 static inline void
vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)8142 vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
8143 {
8144 /* skip val->{sType,pNext} */
8145 vn_decode_VkBool32(dec, &val->shaderZeroInitializeWorkgroupMemory);
8146 }
8147
8148 static inline void
vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)8149 vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
8150 {
8151 VkStructureType stype;
8152 vn_decode_VkStructureType(dec, &stype);
8153 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES);
8154
8155 assert(val->sType == stype);
8156 vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(dec, val->pNext);
8157 vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(dec, val);
8158 }
8159
8160 static inline size_t
vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext_partial(const void * val)8161 vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext_partial(const void *val)
8162 {
8163 /* no known/supported struct */
8164 return vn_sizeof_simple_pointer(NULL);
8165 }
8166
8167 static inline size_t
vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)8168 vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
8169 {
8170 size_t size = 0;
8171 /* skip val->{sType,pNext} */
8172 /* skip val->shaderZeroInitializeWorkgroupMemory */
8173 return size;
8174 }
8175
8176 static inline size_t
vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_partial(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)8177 vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_partial(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
8178 {
8179 size_t size = 0;
8180
8181 size += vn_sizeof_VkStructureType(&val->sType);
8182 size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext_partial(val->pNext);
8183 size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial(val);
8184
8185 return size;
8186 }
8187
8188 static inline void
vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)8189 vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
8190 {
8191 /* no known/supported struct */
8192 vn_encode_simple_pointer(enc, NULL);
8193 }
8194
8195 static inline void
vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)8196 vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
8197 {
8198 /* skip val->{sType,pNext} */
8199 /* skip val->shaderZeroInitializeWorkgroupMemory */
8200 }
8201
8202 static inline void
vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)8203 vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
8204 {
8205 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES);
8206 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES });
8207 vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext_partial(enc, val->pNext);
8208 vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial(enc, val);
8209 }
8210
8211 /* struct VkPhysicalDeviceRobustness2FeaturesEXT chain */
8212
8213 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_pnext(const void * val)8214 vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_pnext(const void *val)
8215 {
8216 /* no known/supported struct */
8217 return vn_sizeof_simple_pointer(NULL);
8218 }
8219
8220 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_self(const VkPhysicalDeviceRobustness2FeaturesEXT * val)8221 vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_self(const VkPhysicalDeviceRobustness2FeaturesEXT *val)
8222 {
8223 size_t size = 0;
8224 /* skip val->{sType,pNext} */
8225 size += vn_sizeof_VkBool32(&val->robustBufferAccess2);
8226 size += vn_sizeof_VkBool32(&val->robustImageAccess2);
8227 size += vn_sizeof_VkBool32(&val->nullDescriptor);
8228 return size;
8229 }
8230
8231 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT(const VkPhysicalDeviceRobustness2FeaturesEXT * val)8232 vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT(const VkPhysicalDeviceRobustness2FeaturesEXT *val)
8233 {
8234 size_t size = 0;
8235
8236 size += vn_sizeof_VkStructureType(&val->sType);
8237 size += vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_pnext(val->pNext);
8238 size += vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_self(val);
8239
8240 return size;
8241 }
8242
8243 static inline void
vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)8244 vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
8245 {
8246 /* no known/supported struct */
8247 vn_encode_simple_pointer(enc, NULL);
8248 }
8249
8250 static inline void
vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceRobustness2FeaturesEXT * val)8251 vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceRobustness2FeaturesEXT *val)
8252 {
8253 /* skip val->{sType,pNext} */
8254 vn_encode_VkBool32(enc, &val->robustBufferAccess2);
8255 vn_encode_VkBool32(enc, &val->robustImageAccess2);
8256 vn_encode_VkBool32(enc, &val->nullDescriptor);
8257 }
8258
8259 static inline void
vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceRobustness2FeaturesEXT * val)8260 vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceRobustness2FeaturesEXT *val)
8261 {
8262 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT);
8263 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT });
8264 vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_pnext(enc, val->pNext);
8265 vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_self(enc, val);
8266 }
8267
8268 static inline void
vn_decode_VkPhysicalDeviceRobustness2FeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)8269 vn_decode_VkPhysicalDeviceRobustness2FeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
8270 {
8271 /* no known/supported struct */
8272 if (vn_decode_simple_pointer(dec))
8273 assert(false);
8274 }
8275
8276 static inline void
vn_decode_VkPhysicalDeviceRobustness2FeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceRobustness2FeaturesEXT * val)8277 vn_decode_VkPhysicalDeviceRobustness2FeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceRobustness2FeaturesEXT *val)
8278 {
8279 /* skip val->{sType,pNext} */
8280 vn_decode_VkBool32(dec, &val->robustBufferAccess2);
8281 vn_decode_VkBool32(dec, &val->robustImageAccess2);
8282 vn_decode_VkBool32(dec, &val->nullDescriptor);
8283 }
8284
8285 static inline void
vn_decode_VkPhysicalDeviceRobustness2FeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceRobustness2FeaturesEXT * val)8286 vn_decode_VkPhysicalDeviceRobustness2FeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceRobustness2FeaturesEXT *val)
8287 {
8288 VkStructureType stype;
8289 vn_decode_VkStructureType(dec, &stype);
8290 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT);
8291
8292 assert(val->sType == stype);
8293 vn_decode_VkPhysicalDeviceRobustness2FeaturesEXT_pnext(dec, val->pNext);
8294 vn_decode_VkPhysicalDeviceRobustness2FeaturesEXT_self(dec, val);
8295 }
8296
8297 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_pnext_partial(const void * val)8298 vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_pnext_partial(const void *val)
8299 {
8300 /* no known/supported struct */
8301 return vn_sizeof_simple_pointer(NULL);
8302 }
8303
8304 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_self_partial(const VkPhysicalDeviceRobustness2FeaturesEXT * val)8305 vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_self_partial(const VkPhysicalDeviceRobustness2FeaturesEXT *val)
8306 {
8307 size_t size = 0;
8308 /* skip val->{sType,pNext} */
8309 /* skip val->robustBufferAccess2 */
8310 /* skip val->robustImageAccess2 */
8311 /* skip val->nullDescriptor */
8312 return size;
8313 }
8314
8315 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_partial(const VkPhysicalDeviceRobustness2FeaturesEXT * val)8316 vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_partial(const VkPhysicalDeviceRobustness2FeaturesEXT *val)
8317 {
8318 size_t size = 0;
8319
8320 size += vn_sizeof_VkStructureType(&val->sType);
8321 size += vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_pnext_partial(val->pNext);
8322 size += vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_self_partial(val);
8323
8324 return size;
8325 }
8326
8327 static inline void
vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)8328 vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
8329 {
8330 /* no known/supported struct */
8331 vn_encode_simple_pointer(enc, NULL);
8332 }
8333
8334 static inline void
vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceRobustness2FeaturesEXT * val)8335 vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceRobustness2FeaturesEXT *val)
8336 {
8337 /* skip val->{sType,pNext} */
8338 /* skip val->robustBufferAccess2 */
8339 /* skip val->robustImageAccess2 */
8340 /* skip val->nullDescriptor */
8341 }
8342
8343 static inline void
vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceRobustness2FeaturesEXT * val)8344 vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceRobustness2FeaturesEXT *val)
8345 {
8346 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT);
8347 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT });
8348 vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_pnext_partial(enc, val->pNext);
8349 vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_self_partial(enc, val);
8350 }
8351
8352 /* struct VkPhysicalDeviceImageRobustnessFeatures chain */
8353
8354 static inline size_t
vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_pnext(const void * val)8355 vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_pnext(const void *val)
8356 {
8357 /* no known/supported struct */
8358 return vn_sizeof_simple_pointer(NULL);
8359 }
8360
8361 static inline size_t
vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self(const VkPhysicalDeviceImageRobustnessFeatures * val)8362 vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self(const VkPhysicalDeviceImageRobustnessFeatures *val)
8363 {
8364 size_t size = 0;
8365 /* skip val->{sType,pNext} */
8366 size += vn_sizeof_VkBool32(&val->robustImageAccess);
8367 return size;
8368 }
8369
8370 static inline size_t
vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures(const VkPhysicalDeviceImageRobustnessFeatures * val)8371 vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures(const VkPhysicalDeviceImageRobustnessFeatures *val)
8372 {
8373 size_t size = 0;
8374
8375 size += vn_sizeof_VkStructureType(&val->sType);
8376 size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_pnext(val->pNext);
8377 size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self(val);
8378
8379 return size;
8380 }
8381
8382 static inline void
vn_encode_VkPhysicalDeviceImageRobustnessFeatures_pnext(struct vn_cs_encoder * enc,const void * val)8383 vn_encode_VkPhysicalDeviceImageRobustnessFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
8384 {
8385 /* no known/supported struct */
8386 vn_encode_simple_pointer(enc, NULL);
8387 }
8388
8389 static inline void
vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageRobustnessFeatures * val)8390 vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageRobustnessFeatures *val)
8391 {
8392 /* skip val->{sType,pNext} */
8393 vn_encode_VkBool32(enc, &val->robustImageAccess);
8394 }
8395
8396 static inline void
vn_encode_VkPhysicalDeviceImageRobustnessFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageRobustnessFeatures * val)8397 vn_encode_VkPhysicalDeviceImageRobustnessFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageRobustnessFeatures *val)
8398 {
8399 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES);
8400 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES });
8401 vn_encode_VkPhysicalDeviceImageRobustnessFeatures_pnext(enc, val->pNext);
8402 vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self(enc, val);
8403 }
8404
8405 static inline void
vn_decode_VkPhysicalDeviceImageRobustnessFeatures_pnext(struct vn_cs_decoder * dec,const void * val)8406 vn_decode_VkPhysicalDeviceImageRobustnessFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
8407 {
8408 /* no known/supported struct */
8409 if (vn_decode_simple_pointer(dec))
8410 assert(false);
8411 }
8412
8413 static inline void
vn_decode_VkPhysicalDeviceImageRobustnessFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceImageRobustnessFeatures * val)8414 vn_decode_VkPhysicalDeviceImageRobustnessFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceImageRobustnessFeatures *val)
8415 {
8416 /* skip val->{sType,pNext} */
8417 vn_decode_VkBool32(dec, &val->robustImageAccess);
8418 }
8419
8420 static inline void
vn_decode_VkPhysicalDeviceImageRobustnessFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceImageRobustnessFeatures * val)8421 vn_decode_VkPhysicalDeviceImageRobustnessFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceImageRobustnessFeatures *val)
8422 {
8423 VkStructureType stype;
8424 vn_decode_VkStructureType(dec, &stype);
8425 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES);
8426
8427 assert(val->sType == stype);
8428 vn_decode_VkPhysicalDeviceImageRobustnessFeatures_pnext(dec, val->pNext);
8429 vn_decode_VkPhysicalDeviceImageRobustnessFeatures_self(dec, val);
8430 }
8431
8432 static inline size_t
vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_pnext_partial(const void * val)8433 vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_pnext_partial(const void *val)
8434 {
8435 /* no known/supported struct */
8436 return vn_sizeof_simple_pointer(NULL);
8437 }
8438
8439 static inline size_t
vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self_partial(const VkPhysicalDeviceImageRobustnessFeatures * val)8440 vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self_partial(const VkPhysicalDeviceImageRobustnessFeatures *val)
8441 {
8442 size_t size = 0;
8443 /* skip val->{sType,pNext} */
8444 /* skip val->robustImageAccess */
8445 return size;
8446 }
8447
8448 static inline size_t
vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_partial(const VkPhysicalDeviceImageRobustnessFeatures * val)8449 vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_partial(const VkPhysicalDeviceImageRobustnessFeatures *val)
8450 {
8451 size_t size = 0;
8452
8453 size += vn_sizeof_VkStructureType(&val->sType);
8454 size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_pnext_partial(val->pNext);
8455 size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self_partial(val);
8456
8457 return size;
8458 }
8459
8460 static inline void
vn_encode_VkPhysicalDeviceImageRobustnessFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)8461 vn_encode_VkPhysicalDeviceImageRobustnessFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
8462 {
8463 /* no known/supported struct */
8464 vn_encode_simple_pointer(enc, NULL);
8465 }
8466
8467 static inline void
vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageRobustnessFeatures * val)8468 vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageRobustnessFeatures *val)
8469 {
8470 /* skip val->{sType,pNext} */
8471 /* skip val->robustImageAccess */
8472 }
8473
8474 static inline void
vn_encode_VkPhysicalDeviceImageRobustnessFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageRobustnessFeatures * val)8475 vn_encode_VkPhysicalDeviceImageRobustnessFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageRobustnessFeatures *val)
8476 {
8477 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES);
8478 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES });
8479 vn_encode_VkPhysicalDeviceImageRobustnessFeatures_pnext_partial(enc, val->pNext);
8480 vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self_partial(enc, val);
8481 }
8482
8483 /* struct VkPhysicalDevice4444FormatsFeaturesEXT chain */
8484
8485 static inline size_t
vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(const void * val)8486 vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(const void *val)
8487 {
8488 /* no known/supported struct */
8489 return vn_sizeof_simple_pointer(NULL);
8490 }
8491
8492 static inline size_t
vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self(const VkPhysicalDevice4444FormatsFeaturesEXT * val)8493 vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self(const VkPhysicalDevice4444FormatsFeaturesEXT *val)
8494 {
8495 size_t size = 0;
8496 /* skip val->{sType,pNext} */
8497 size += vn_sizeof_VkBool32(&val->formatA4R4G4B4);
8498 size += vn_sizeof_VkBool32(&val->formatA4B4G4R4);
8499 return size;
8500 }
8501
8502 static inline size_t
vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT(const VkPhysicalDevice4444FormatsFeaturesEXT * val)8503 vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT(const VkPhysicalDevice4444FormatsFeaturesEXT *val)
8504 {
8505 size_t size = 0;
8506
8507 size += vn_sizeof_VkStructureType(&val->sType);
8508 size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(val->pNext);
8509 size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self(val);
8510
8511 return size;
8512 }
8513
8514 static inline void
vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)8515 vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
8516 {
8517 /* no known/supported struct */
8518 vn_encode_simple_pointer(enc, NULL);
8519 }
8520
8521 static inline void
vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDevice4444FormatsFeaturesEXT * val)8522 vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDevice4444FormatsFeaturesEXT *val)
8523 {
8524 /* skip val->{sType,pNext} */
8525 vn_encode_VkBool32(enc, &val->formatA4R4G4B4);
8526 vn_encode_VkBool32(enc, &val->formatA4B4G4R4);
8527 }
8528
8529 static inline void
vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDevice4444FormatsFeaturesEXT * val)8530 vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDevice4444FormatsFeaturesEXT *val)
8531 {
8532 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT);
8533 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT });
8534 vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(enc, val->pNext);
8535 vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self(enc, val);
8536 }
8537
8538 static inline void
vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)8539 vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
8540 {
8541 /* no known/supported struct */
8542 if (vn_decode_simple_pointer(dec))
8543 assert(false);
8544 }
8545
8546 static inline void
vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDevice4444FormatsFeaturesEXT * val)8547 vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDevice4444FormatsFeaturesEXT *val)
8548 {
8549 /* skip val->{sType,pNext} */
8550 vn_decode_VkBool32(dec, &val->formatA4R4G4B4);
8551 vn_decode_VkBool32(dec, &val->formatA4B4G4R4);
8552 }
8553
8554 static inline void
vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDevice4444FormatsFeaturesEXT * val)8555 vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDevice4444FormatsFeaturesEXT *val)
8556 {
8557 VkStructureType stype;
8558 vn_decode_VkStructureType(dec, &stype);
8559 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT);
8560
8561 assert(val->sType == stype);
8562 vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(dec, val->pNext);
8563 vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT_self(dec, val);
8564 }
8565
8566 static inline size_t
vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_pnext_partial(const void * val)8567 vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_pnext_partial(const void *val)
8568 {
8569 /* no known/supported struct */
8570 return vn_sizeof_simple_pointer(NULL);
8571 }
8572
8573 static inline size_t
vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial(const VkPhysicalDevice4444FormatsFeaturesEXT * val)8574 vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial(const VkPhysicalDevice4444FormatsFeaturesEXT *val)
8575 {
8576 size_t size = 0;
8577 /* skip val->{sType,pNext} */
8578 /* skip val->formatA4R4G4B4 */
8579 /* skip val->formatA4B4G4R4 */
8580 return size;
8581 }
8582
8583 static inline size_t
vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_partial(const VkPhysicalDevice4444FormatsFeaturesEXT * val)8584 vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_partial(const VkPhysicalDevice4444FormatsFeaturesEXT *val)
8585 {
8586 size_t size = 0;
8587
8588 size += vn_sizeof_VkStructureType(&val->sType);
8589 size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_pnext_partial(val->pNext);
8590 size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial(val);
8591
8592 return size;
8593 }
8594
8595 static inline void
vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)8596 vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
8597 {
8598 /* no known/supported struct */
8599 vn_encode_simple_pointer(enc, NULL);
8600 }
8601
8602 static inline void
vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevice4444FormatsFeaturesEXT * val)8603 vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice4444FormatsFeaturesEXT *val)
8604 {
8605 /* skip val->{sType,pNext} */
8606 /* skip val->formatA4R4G4B4 */
8607 /* skip val->formatA4B4G4R4 */
8608 }
8609
8610 static inline void
vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDevice4444FormatsFeaturesEXT * val)8611 vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice4444FormatsFeaturesEXT *val)
8612 {
8613 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT);
8614 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT });
8615 vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext_partial(enc, val->pNext);
8616 vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial(enc, val);
8617 }
8618
8619 /* struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR chain */
8620
8621 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_pnext(const void * val)8622 vn_sizeof_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_pnext(const void *val)
8623 {
8624 /* no known/supported struct */
8625 return vn_sizeof_simple_pointer(NULL);
8626 }
8627
8628 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR * val)8629 vn_sizeof_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *val)
8630 {
8631 size_t size = 0;
8632 /* skip val->{sType,pNext} */
8633 size += vn_sizeof_VkBool32(&val->pipelineFragmentShadingRate);
8634 size += vn_sizeof_VkBool32(&val->primitiveFragmentShadingRate);
8635 size += vn_sizeof_VkBool32(&val->attachmentFragmentShadingRate);
8636 return size;
8637 }
8638
8639 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR * val)8640 vn_sizeof_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *val)
8641 {
8642 size_t size = 0;
8643
8644 size += vn_sizeof_VkStructureType(&val->sType);
8645 size += vn_sizeof_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_pnext(val->pNext);
8646 size += vn_sizeof_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self(val);
8647
8648 return size;
8649 }
8650
8651 static inline void
vn_encode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_pnext(struct vn_cs_encoder * enc,const void * val)8652 vn_encode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_pnext(struct vn_cs_encoder *enc, const void *val)
8653 {
8654 /* no known/supported struct */
8655 vn_encode_simple_pointer(enc, NULL);
8656 }
8657
8658 static inline void
vn_encode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceFragmentShadingRateFeaturesKHR * val)8659 vn_encode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *val)
8660 {
8661 /* skip val->{sType,pNext} */
8662 vn_encode_VkBool32(enc, &val->pipelineFragmentShadingRate);
8663 vn_encode_VkBool32(enc, &val->primitiveFragmentShadingRate);
8664 vn_encode_VkBool32(enc, &val->attachmentFragmentShadingRate);
8665 }
8666
8667 static inline void
vn_encode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(struct vn_cs_encoder * enc,const VkPhysicalDeviceFragmentShadingRateFeaturesKHR * val)8668 vn_encode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(struct vn_cs_encoder *enc, const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *val)
8669 {
8670 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR);
8671 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR });
8672 vn_encode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_pnext(enc, val->pNext);
8673 vn_encode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self(enc, val);
8674 }
8675
8676 static inline void
vn_decode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_pnext(struct vn_cs_decoder * dec,const void * val)8677 vn_decode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_pnext(struct vn_cs_decoder *dec, const void *val)
8678 {
8679 /* no known/supported struct */
8680 if (vn_decode_simple_pointer(dec))
8681 assert(false);
8682 }
8683
8684 static inline void
vn_decode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self(struct vn_cs_decoder * dec,VkPhysicalDeviceFragmentShadingRateFeaturesKHR * val)8685 vn_decode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self(struct vn_cs_decoder *dec, VkPhysicalDeviceFragmentShadingRateFeaturesKHR *val)
8686 {
8687 /* skip val->{sType,pNext} */
8688 vn_decode_VkBool32(dec, &val->pipelineFragmentShadingRate);
8689 vn_decode_VkBool32(dec, &val->primitiveFragmentShadingRate);
8690 vn_decode_VkBool32(dec, &val->attachmentFragmentShadingRate);
8691 }
8692
8693 static inline void
vn_decode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(struct vn_cs_decoder * dec,VkPhysicalDeviceFragmentShadingRateFeaturesKHR * val)8694 vn_decode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(struct vn_cs_decoder *dec, VkPhysicalDeviceFragmentShadingRateFeaturesKHR *val)
8695 {
8696 VkStructureType stype;
8697 vn_decode_VkStructureType(dec, &stype);
8698 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR);
8699
8700 assert(val->sType == stype);
8701 vn_decode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_pnext(dec, val->pNext);
8702 vn_decode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self(dec, val);
8703 }
8704
8705 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_pnext_partial(const void * val)8706 vn_sizeof_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_pnext_partial(const void *val)
8707 {
8708 /* no known/supported struct */
8709 return vn_sizeof_simple_pointer(NULL);
8710 }
8711
8712 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self_partial(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR * val)8713 vn_sizeof_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self_partial(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *val)
8714 {
8715 size_t size = 0;
8716 /* skip val->{sType,pNext} */
8717 /* skip val->pipelineFragmentShadingRate */
8718 /* skip val->primitiveFragmentShadingRate */
8719 /* skip val->attachmentFragmentShadingRate */
8720 return size;
8721 }
8722
8723 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_partial(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR * val)8724 vn_sizeof_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_partial(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *val)
8725 {
8726 size_t size = 0;
8727
8728 size += vn_sizeof_VkStructureType(&val->sType);
8729 size += vn_sizeof_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_pnext_partial(val->pNext);
8730 size += vn_sizeof_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self_partial(val);
8731
8732 return size;
8733 }
8734
8735 static inline void
vn_encode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_pnext_partial(struct vn_cs_encoder * enc,const void * val)8736 vn_encode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_pnext_partial(struct vn_cs_encoder *enc, const void *val)
8737 {
8738 /* no known/supported struct */
8739 vn_encode_simple_pointer(enc, NULL);
8740 }
8741
8742 static inline void
vn_encode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFragmentShadingRateFeaturesKHR * val)8743 vn_encode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *val)
8744 {
8745 /* skip val->{sType,pNext} */
8746 /* skip val->pipelineFragmentShadingRate */
8747 /* skip val->primitiveFragmentShadingRate */
8748 /* skip val->attachmentFragmentShadingRate */
8749 }
8750
8751 static inline void
vn_encode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFragmentShadingRateFeaturesKHR * val)8752 vn_encode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *val)
8753 {
8754 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR);
8755 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR });
8756 vn_encode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_pnext_partial(enc, val->pNext);
8757 vn_encode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self_partial(enc, val);
8758 }
8759
8760 /* struct VkPhysicalDeviceShaderTerminateInvocationFeatures chain */
8761
8762 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(const void * val)8763 vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(const void *val)
8764 {
8765 /* no known/supported struct */
8766 return vn_sizeof_simple_pointer(NULL);
8767 }
8768
8769 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(const VkPhysicalDeviceShaderTerminateInvocationFeatures * val)8770 vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(const VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
8771 {
8772 size_t size = 0;
8773 /* skip val->{sType,pNext} */
8774 size += vn_sizeof_VkBool32(&val->shaderTerminateInvocation);
8775 return size;
8776 }
8777
8778 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures(const VkPhysicalDeviceShaderTerminateInvocationFeatures * val)8779 vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures(const VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
8780 {
8781 size_t size = 0;
8782
8783 size += vn_sizeof_VkStructureType(&val->sType);
8784 size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(val->pNext);
8785 size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(val);
8786
8787 return size;
8788 }
8789
8790 static inline void
vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(struct vn_cs_encoder * enc,const void * val)8791 vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
8792 {
8793 /* no known/supported struct */
8794 vn_encode_simple_pointer(enc, NULL);
8795 }
8796
8797 static inline void
vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderTerminateInvocationFeatures * val)8798 vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
8799 {
8800 /* skip val->{sType,pNext} */
8801 vn_encode_VkBool32(enc, &val->shaderTerminateInvocation);
8802 }
8803
8804 static inline void
vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderTerminateInvocationFeatures * val)8805 vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
8806 {
8807 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES);
8808 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES });
8809 vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(enc, val->pNext);
8810 vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(enc, val);
8811 }
8812
8813 static inline void
vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(struct vn_cs_decoder * dec,const void * val)8814 vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
8815 {
8816 /* no known/supported struct */
8817 if (vn_decode_simple_pointer(dec))
8818 assert(false);
8819 }
8820
8821 static inline void
vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderTerminateInvocationFeatures * val)8822 vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
8823 {
8824 /* skip val->{sType,pNext} */
8825 vn_decode_VkBool32(dec, &val->shaderTerminateInvocation);
8826 }
8827
8828 static inline void
vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderTerminateInvocationFeatures * val)8829 vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
8830 {
8831 VkStructureType stype;
8832 vn_decode_VkStructureType(dec, &stype);
8833 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES);
8834
8835 assert(val->sType == stype);
8836 vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(dec, val->pNext);
8837 vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(dec, val);
8838 }
8839
8840 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext_partial(const void * val)8841 vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext_partial(const void *val)
8842 {
8843 /* no known/supported struct */
8844 return vn_sizeof_simple_pointer(NULL);
8845 }
8846
8847 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial(const VkPhysicalDeviceShaderTerminateInvocationFeatures * val)8848 vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial(const VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
8849 {
8850 size_t size = 0;
8851 /* skip val->{sType,pNext} */
8852 /* skip val->shaderTerminateInvocation */
8853 return size;
8854 }
8855
8856 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_partial(const VkPhysicalDeviceShaderTerminateInvocationFeatures * val)8857 vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_partial(const VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
8858 {
8859 size_t size = 0;
8860
8861 size += vn_sizeof_VkStructureType(&val->sType);
8862 size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext_partial(val->pNext);
8863 size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial(val);
8864
8865 return size;
8866 }
8867
8868 static inline void
vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)8869 vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
8870 {
8871 /* no known/supported struct */
8872 vn_encode_simple_pointer(enc, NULL);
8873 }
8874
8875 static inline void
vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderTerminateInvocationFeatures * val)8876 vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
8877 {
8878 /* skip val->{sType,pNext} */
8879 /* skip val->shaderTerminateInvocation */
8880 }
8881
8882 static inline void
vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderTerminateInvocationFeatures * val)8883 vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
8884 {
8885 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES);
8886 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES });
8887 vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext_partial(enc, val->pNext);
8888 vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial(enc, val);
8889 }
8890
8891 /* struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT chain */
8892
8893 static inline size_t
vn_sizeof_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_pnext(const void * val)8894 vn_sizeof_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_pnext(const void *val)
8895 {
8896 /* no known/supported struct */
8897 return vn_sizeof_simple_pointer(NULL);
8898 }
8899
8900 static inline size_t
vn_sizeof_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT * val)8901 vn_sizeof_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *val)
8902 {
8903 size_t size = 0;
8904 /* skip val->{sType,pNext} */
8905 size += vn_sizeof_VkBool32(&val->image2DViewOf3D);
8906 size += vn_sizeof_VkBool32(&val->sampler2DViewOf3D);
8907 return size;
8908 }
8909
8910 static inline size_t
vn_sizeof_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT * val)8911 vn_sizeof_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *val)
8912 {
8913 size_t size = 0;
8914
8915 size += vn_sizeof_VkStructureType(&val->sType);
8916 size += vn_sizeof_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_pnext(val->pNext);
8917 size += vn_sizeof_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self(val);
8918
8919 return size;
8920 }
8921
8922 static inline void
vn_encode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)8923 vn_encode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
8924 {
8925 /* no known/supported struct */
8926 vn_encode_simple_pointer(enc, NULL);
8927 }
8928
8929 static inline void
vn_encode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT * val)8930 vn_encode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *val)
8931 {
8932 /* skip val->{sType,pNext} */
8933 vn_encode_VkBool32(enc, &val->image2DViewOf3D);
8934 vn_encode_VkBool32(enc, &val->sampler2DViewOf3D);
8935 }
8936
8937 static inline void
vn_encode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT * val)8938 vn_encode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *val)
8939 {
8940 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT);
8941 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT });
8942 vn_encode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_pnext(enc, val->pNext);
8943 vn_encode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self(enc, val);
8944 }
8945
8946 static inline void
vn_decode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)8947 vn_decode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
8948 {
8949 /* no known/supported struct */
8950 if (vn_decode_simple_pointer(dec))
8951 assert(false);
8952 }
8953
8954 static inline void
vn_decode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceImage2DViewOf3DFeaturesEXT * val)8955 vn_decode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *val)
8956 {
8957 /* skip val->{sType,pNext} */
8958 vn_decode_VkBool32(dec, &val->image2DViewOf3D);
8959 vn_decode_VkBool32(dec, &val->sampler2DViewOf3D);
8960 }
8961
8962 static inline void
vn_decode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceImage2DViewOf3DFeaturesEXT * val)8963 vn_decode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *val)
8964 {
8965 VkStructureType stype;
8966 vn_decode_VkStructureType(dec, &stype);
8967 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT);
8968
8969 assert(val->sType == stype);
8970 vn_decode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_pnext(dec, val->pNext);
8971 vn_decode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self(dec, val);
8972 }
8973
8974 static inline size_t
vn_sizeof_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_pnext_partial(const void * val)8975 vn_sizeof_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_pnext_partial(const void *val)
8976 {
8977 /* no known/supported struct */
8978 return vn_sizeof_simple_pointer(NULL);
8979 }
8980
8981 static inline size_t
vn_sizeof_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self_partial(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT * val)8982 vn_sizeof_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self_partial(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *val)
8983 {
8984 size_t size = 0;
8985 /* skip val->{sType,pNext} */
8986 /* skip val->image2DViewOf3D */
8987 /* skip val->sampler2DViewOf3D */
8988 return size;
8989 }
8990
8991 static inline size_t
vn_sizeof_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_partial(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT * val)8992 vn_sizeof_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_partial(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *val)
8993 {
8994 size_t size = 0;
8995
8996 size += vn_sizeof_VkStructureType(&val->sType);
8997 size += vn_sizeof_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_pnext_partial(val->pNext);
8998 size += vn_sizeof_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self_partial(val);
8999
9000 return size;
9001 }
9002
9003 static inline void
vn_encode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)9004 vn_encode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9005 {
9006 /* no known/supported struct */
9007 vn_encode_simple_pointer(enc, NULL);
9008 }
9009
9010 static inline void
vn_encode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT * val)9011 vn_encode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *val)
9012 {
9013 /* skip val->{sType,pNext} */
9014 /* skip val->image2DViewOf3D */
9015 /* skip val->sampler2DViewOf3D */
9016 }
9017
9018 static inline void
vn_encode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT * val)9019 vn_encode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *val)
9020 {
9021 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT);
9022 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT });
9023 vn_encode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_pnext_partial(enc, val->pNext);
9024 vn_encode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self_partial(enc, val);
9025 }
9026
9027 /* struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT chain */
9028
9029 static inline size_t
vn_sizeof_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_pnext(const void * val)9030 vn_sizeof_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_pnext(const void *val)
9031 {
9032 /* no known/supported struct */
9033 return vn_sizeof_simple_pointer(NULL);
9034 }
9035
9036 static inline size_t
vn_sizeof_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self(const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT * val)9037 vn_sizeof_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self(const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *val)
9038 {
9039 size_t size = 0;
9040 /* skip val->{sType,pNext} */
9041 size += vn_sizeof_VkBool32(&val->mutableDescriptorType);
9042 return size;
9043 }
9044
9045 static inline size_t
vn_sizeof_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT * val)9046 vn_sizeof_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *val)
9047 {
9048 size_t size = 0;
9049
9050 size += vn_sizeof_VkStructureType(&val->sType);
9051 size += vn_sizeof_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_pnext(val->pNext);
9052 size += vn_sizeof_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self(val);
9053
9054 return size;
9055 }
9056
9057 static inline void
vn_encode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)9058 vn_encode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
9059 {
9060 /* no known/supported struct */
9061 vn_encode_simple_pointer(enc, NULL);
9062 }
9063
9064 static inline void
vn_encode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT * val)9065 vn_encode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *val)
9066 {
9067 /* skip val->{sType,pNext} */
9068 vn_encode_VkBool32(enc, &val->mutableDescriptorType);
9069 }
9070
9071 static inline void
vn_encode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT * val)9072 vn_encode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *val)
9073 {
9074 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT);
9075 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT });
9076 vn_encode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_pnext(enc, val->pNext);
9077 vn_encode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self(enc, val);
9078 }
9079
9080 static inline void
vn_decode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)9081 vn_decode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
9082 {
9083 /* no known/supported struct */
9084 if (vn_decode_simple_pointer(dec))
9085 assert(false);
9086 }
9087
9088 static inline void
vn_decode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT * val)9089 vn_decode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *val)
9090 {
9091 /* skip val->{sType,pNext} */
9092 vn_decode_VkBool32(dec, &val->mutableDescriptorType);
9093 }
9094
9095 static inline void
vn_decode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT * val)9096 vn_decode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *val)
9097 {
9098 VkStructureType stype;
9099 vn_decode_VkStructureType(dec, &stype);
9100 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT);
9101
9102 assert(val->sType == stype);
9103 vn_decode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_pnext(dec, val->pNext);
9104 vn_decode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self(dec, val);
9105 }
9106
9107 static inline size_t
vn_sizeof_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_pnext_partial(const void * val)9108 vn_sizeof_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_pnext_partial(const void *val)
9109 {
9110 /* no known/supported struct */
9111 return vn_sizeof_simple_pointer(NULL);
9112 }
9113
9114 static inline size_t
vn_sizeof_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self_partial(const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT * val)9115 vn_sizeof_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self_partial(const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *val)
9116 {
9117 size_t size = 0;
9118 /* skip val->{sType,pNext} */
9119 /* skip val->mutableDescriptorType */
9120 return size;
9121 }
9122
9123 static inline size_t
vn_sizeof_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_partial(const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT * val)9124 vn_sizeof_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_partial(const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *val)
9125 {
9126 size_t size = 0;
9127
9128 size += vn_sizeof_VkStructureType(&val->sType);
9129 size += vn_sizeof_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_pnext_partial(val->pNext);
9130 size += vn_sizeof_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self_partial(val);
9131
9132 return size;
9133 }
9134
9135 static inline void
vn_encode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)9136 vn_encode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9137 {
9138 /* no known/supported struct */
9139 vn_encode_simple_pointer(enc, NULL);
9140 }
9141
9142 static inline void
vn_encode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT * val)9143 vn_encode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *val)
9144 {
9145 /* skip val->{sType,pNext} */
9146 /* skip val->mutableDescriptorType */
9147 }
9148
9149 static inline void
vn_encode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT * val)9150 vn_encode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *val)
9151 {
9152 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT);
9153 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT });
9154 vn_encode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_pnext_partial(enc, val->pNext);
9155 vn_encode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self_partial(enc, val);
9156 }
9157
9158 /* struct VkPhysicalDeviceDepthClipControlFeaturesEXT chain */
9159
9160 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthClipControlFeaturesEXT_pnext(const void * val)9161 vn_sizeof_VkPhysicalDeviceDepthClipControlFeaturesEXT_pnext(const void *val)
9162 {
9163 /* no known/supported struct */
9164 return vn_sizeof_simple_pointer(NULL);
9165 }
9166
9167 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthClipControlFeaturesEXT_self(const VkPhysicalDeviceDepthClipControlFeaturesEXT * val)9168 vn_sizeof_VkPhysicalDeviceDepthClipControlFeaturesEXT_self(const VkPhysicalDeviceDepthClipControlFeaturesEXT *val)
9169 {
9170 size_t size = 0;
9171 /* skip val->{sType,pNext} */
9172 size += vn_sizeof_VkBool32(&val->depthClipControl);
9173 return size;
9174 }
9175
9176 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthClipControlFeaturesEXT(const VkPhysicalDeviceDepthClipControlFeaturesEXT * val)9177 vn_sizeof_VkPhysicalDeviceDepthClipControlFeaturesEXT(const VkPhysicalDeviceDepthClipControlFeaturesEXT *val)
9178 {
9179 size_t size = 0;
9180
9181 size += vn_sizeof_VkStructureType(&val->sType);
9182 size += vn_sizeof_VkPhysicalDeviceDepthClipControlFeaturesEXT_pnext(val->pNext);
9183 size += vn_sizeof_VkPhysicalDeviceDepthClipControlFeaturesEXT_self(val);
9184
9185 return size;
9186 }
9187
9188 static inline void
vn_encode_VkPhysicalDeviceDepthClipControlFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)9189 vn_encode_VkPhysicalDeviceDepthClipControlFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
9190 {
9191 /* no known/supported struct */
9192 vn_encode_simple_pointer(enc, NULL);
9193 }
9194
9195 static inline void
vn_encode_VkPhysicalDeviceDepthClipControlFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthClipControlFeaturesEXT * val)9196 vn_encode_VkPhysicalDeviceDepthClipControlFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthClipControlFeaturesEXT *val)
9197 {
9198 /* skip val->{sType,pNext} */
9199 vn_encode_VkBool32(enc, &val->depthClipControl);
9200 }
9201
9202 static inline void
vn_encode_VkPhysicalDeviceDepthClipControlFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthClipControlFeaturesEXT * val)9203 vn_encode_VkPhysicalDeviceDepthClipControlFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthClipControlFeaturesEXT *val)
9204 {
9205 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT);
9206 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT });
9207 vn_encode_VkPhysicalDeviceDepthClipControlFeaturesEXT_pnext(enc, val->pNext);
9208 vn_encode_VkPhysicalDeviceDepthClipControlFeaturesEXT_self(enc, val);
9209 }
9210
9211 static inline void
vn_decode_VkPhysicalDeviceDepthClipControlFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)9212 vn_decode_VkPhysicalDeviceDepthClipControlFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
9213 {
9214 /* no known/supported struct */
9215 if (vn_decode_simple_pointer(dec))
9216 assert(false);
9217 }
9218
9219 static inline void
vn_decode_VkPhysicalDeviceDepthClipControlFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDepthClipControlFeaturesEXT * val)9220 vn_decode_VkPhysicalDeviceDepthClipControlFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthClipControlFeaturesEXT *val)
9221 {
9222 /* skip val->{sType,pNext} */
9223 vn_decode_VkBool32(dec, &val->depthClipControl);
9224 }
9225
9226 static inline void
vn_decode_VkPhysicalDeviceDepthClipControlFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceDepthClipControlFeaturesEXT * val)9227 vn_decode_VkPhysicalDeviceDepthClipControlFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthClipControlFeaturesEXT *val)
9228 {
9229 VkStructureType stype;
9230 vn_decode_VkStructureType(dec, &stype);
9231 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT);
9232
9233 assert(val->sType == stype);
9234 vn_decode_VkPhysicalDeviceDepthClipControlFeaturesEXT_pnext(dec, val->pNext);
9235 vn_decode_VkPhysicalDeviceDepthClipControlFeaturesEXT_self(dec, val);
9236 }
9237
9238 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthClipControlFeaturesEXT_pnext_partial(const void * val)9239 vn_sizeof_VkPhysicalDeviceDepthClipControlFeaturesEXT_pnext_partial(const void *val)
9240 {
9241 /* no known/supported struct */
9242 return vn_sizeof_simple_pointer(NULL);
9243 }
9244
9245 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthClipControlFeaturesEXT_self_partial(const VkPhysicalDeviceDepthClipControlFeaturesEXT * val)9246 vn_sizeof_VkPhysicalDeviceDepthClipControlFeaturesEXT_self_partial(const VkPhysicalDeviceDepthClipControlFeaturesEXT *val)
9247 {
9248 size_t size = 0;
9249 /* skip val->{sType,pNext} */
9250 /* skip val->depthClipControl */
9251 return size;
9252 }
9253
9254 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthClipControlFeaturesEXT_partial(const VkPhysicalDeviceDepthClipControlFeaturesEXT * val)9255 vn_sizeof_VkPhysicalDeviceDepthClipControlFeaturesEXT_partial(const VkPhysicalDeviceDepthClipControlFeaturesEXT *val)
9256 {
9257 size_t size = 0;
9258
9259 size += vn_sizeof_VkStructureType(&val->sType);
9260 size += vn_sizeof_VkPhysicalDeviceDepthClipControlFeaturesEXT_pnext_partial(val->pNext);
9261 size += vn_sizeof_VkPhysicalDeviceDepthClipControlFeaturesEXT_self_partial(val);
9262
9263 return size;
9264 }
9265
9266 static inline void
vn_encode_VkPhysicalDeviceDepthClipControlFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)9267 vn_encode_VkPhysicalDeviceDepthClipControlFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9268 {
9269 /* no known/supported struct */
9270 vn_encode_simple_pointer(enc, NULL);
9271 }
9272
9273 static inline void
vn_encode_VkPhysicalDeviceDepthClipControlFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthClipControlFeaturesEXT * val)9274 vn_encode_VkPhysicalDeviceDepthClipControlFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthClipControlFeaturesEXT *val)
9275 {
9276 /* skip val->{sType,pNext} */
9277 /* skip val->depthClipControl */
9278 }
9279
9280 static inline void
vn_encode_VkPhysicalDeviceDepthClipControlFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthClipControlFeaturesEXT * val)9281 vn_encode_VkPhysicalDeviceDepthClipControlFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthClipControlFeaturesEXT *val)
9282 {
9283 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT);
9284 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT });
9285 vn_encode_VkPhysicalDeviceDepthClipControlFeaturesEXT_pnext_partial(enc, val->pNext);
9286 vn_encode_VkPhysicalDeviceDepthClipControlFeaturesEXT_self_partial(enc, val);
9287 }
9288
9289 /* struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT chain */
9290
9291 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_pnext(const void * val)9292 vn_sizeof_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_pnext(const void *val)
9293 {
9294 /* no known/supported struct */
9295 return vn_sizeof_simple_pointer(NULL);
9296 }
9297
9298 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT * val)9299 vn_sizeof_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *val)
9300 {
9301 size_t size = 0;
9302 /* skip val->{sType,pNext} */
9303 size += vn_sizeof_VkBool32(&val->vertexInputDynamicState);
9304 return size;
9305 }
9306
9307 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT * val)9308 vn_sizeof_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *val)
9309 {
9310 size_t size = 0;
9311
9312 size += vn_sizeof_VkStructureType(&val->sType);
9313 size += vn_sizeof_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_pnext(val->pNext);
9314 size += vn_sizeof_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self(val);
9315
9316 return size;
9317 }
9318
9319 static inline void
vn_encode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)9320 vn_encode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
9321 {
9322 /* no known/supported struct */
9323 vn_encode_simple_pointer(enc, NULL);
9324 }
9325
9326 static inline void
vn_encode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT * val)9327 vn_encode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *val)
9328 {
9329 /* skip val->{sType,pNext} */
9330 vn_encode_VkBool32(enc, &val->vertexInputDynamicState);
9331 }
9332
9333 static inline void
vn_encode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT * val)9334 vn_encode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *val)
9335 {
9336 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT);
9337 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT });
9338 vn_encode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_pnext(enc, val->pNext);
9339 vn_encode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self(enc, val);
9340 }
9341
9342 static inline void
vn_decode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)9343 vn_decode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
9344 {
9345 /* no known/supported struct */
9346 if (vn_decode_simple_pointer(dec))
9347 assert(false);
9348 }
9349
9350 static inline void
vn_decode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT * val)9351 vn_decode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *val)
9352 {
9353 /* skip val->{sType,pNext} */
9354 vn_decode_VkBool32(dec, &val->vertexInputDynamicState);
9355 }
9356
9357 static inline void
vn_decode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT * val)9358 vn_decode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *val)
9359 {
9360 VkStructureType stype;
9361 vn_decode_VkStructureType(dec, &stype);
9362 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT);
9363
9364 assert(val->sType == stype);
9365 vn_decode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_pnext(dec, val->pNext);
9366 vn_decode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self(dec, val);
9367 }
9368
9369 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_pnext_partial(const void * val)9370 vn_sizeof_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_pnext_partial(const void *val)
9371 {
9372 /* no known/supported struct */
9373 return vn_sizeof_simple_pointer(NULL);
9374 }
9375
9376 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self_partial(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT * val)9377 vn_sizeof_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self_partial(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *val)
9378 {
9379 size_t size = 0;
9380 /* skip val->{sType,pNext} */
9381 /* skip val->vertexInputDynamicState */
9382 return size;
9383 }
9384
9385 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_partial(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT * val)9386 vn_sizeof_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_partial(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *val)
9387 {
9388 size_t size = 0;
9389
9390 size += vn_sizeof_VkStructureType(&val->sType);
9391 size += vn_sizeof_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_pnext_partial(val->pNext);
9392 size += vn_sizeof_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self_partial(val);
9393
9394 return size;
9395 }
9396
9397 static inline void
vn_encode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)9398 vn_encode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9399 {
9400 /* no known/supported struct */
9401 vn_encode_simple_pointer(enc, NULL);
9402 }
9403
9404 static inline void
vn_encode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT * val)9405 vn_encode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *val)
9406 {
9407 /* skip val->{sType,pNext} */
9408 /* skip val->vertexInputDynamicState */
9409 }
9410
9411 static inline void
vn_encode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT * val)9412 vn_encode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *val)
9413 {
9414 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT);
9415 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT });
9416 vn_encode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_pnext_partial(enc, val->pNext);
9417 vn_encode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self_partial(enc, val);
9418 }
9419
9420 /* struct VkPhysicalDeviceColorWriteEnableFeaturesEXT chain */
9421
9422 static inline size_t
vn_sizeof_VkPhysicalDeviceColorWriteEnableFeaturesEXT_pnext(const void * val)9423 vn_sizeof_VkPhysicalDeviceColorWriteEnableFeaturesEXT_pnext(const void *val)
9424 {
9425 /* no known/supported struct */
9426 return vn_sizeof_simple_pointer(NULL);
9427 }
9428
9429 static inline size_t
vn_sizeof_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self(const VkPhysicalDeviceColorWriteEnableFeaturesEXT * val)9430 vn_sizeof_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self(const VkPhysicalDeviceColorWriteEnableFeaturesEXT *val)
9431 {
9432 size_t size = 0;
9433 /* skip val->{sType,pNext} */
9434 size += vn_sizeof_VkBool32(&val->colorWriteEnable);
9435 return size;
9436 }
9437
9438 static inline size_t
vn_sizeof_VkPhysicalDeviceColorWriteEnableFeaturesEXT(const VkPhysicalDeviceColorWriteEnableFeaturesEXT * val)9439 vn_sizeof_VkPhysicalDeviceColorWriteEnableFeaturesEXT(const VkPhysicalDeviceColorWriteEnableFeaturesEXT *val)
9440 {
9441 size_t size = 0;
9442
9443 size += vn_sizeof_VkStructureType(&val->sType);
9444 size += vn_sizeof_VkPhysicalDeviceColorWriteEnableFeaturesEXT_pnext(val->pNext);
9445 size += vn_sizeof_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self(val);
9446
9447 return size;
9448 }
9449
9450 static inline void
vn_encode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)9451 vn_encode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
9452 {
9453 /* no known/supported struct */
9454 vn_encode_simple_pointer(enc, NULL);
9455 }
9456
9457 static inline void
vn_encode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceColorWriteEnableFeaturesEXT * val)9458 vn_encode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceColorWriteEnableFeaturesEXT *val)
9459 {
9460 /* skip val->{sType,pNext} */
9461 vn_encode_VkBool32(enc, &val->colorWriteEnable);
9462 }
9463
9464 static inline void
vn_encode_VkPhysicalDeviceColorWriteEnableFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceColorWriteEnableFeaturesEXT * val)9465 vn_encode_VkPhysicalDeviceColorWriteEnableFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceColorWriteEnableFeaturesEXT *val)
9466 {
9467 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT);
9468 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT });
9469 vn_encode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_pnext(enc, val->pNext);
9470 vn_encode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self(enc, val);
9471 }
9472
9473 static inline void
vn_decode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)9474 vn_decode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
9475 {
9476 /* no known/supported struct */
9477 if (vn_decode_simple_pointer(dec))
9478 assert(false);
9479 }
9480
9481 static inline void
vn_decode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceColorWriteEnableFeaturesEXT * val)9482 vn_decode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceColorWriteEnableFeaturesEXT *val)
9483 {
9484 /* skip val->{sType,pNext} */
9485 vn_decode_VkBool32(dec, &val->colorWriteEnable);
9486 }
9487
9488 static inline void
vn_decode_VkPhysicalDeviceColorWriteEnableFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceColorWriteEnableFeaturesEXT * val)9489 vn_decode_VkPhysicalDeviceColorWriteEnableFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceColorWriteEnableFeaturesEXT *val)
9490 {
9491 VkStructureType stype;
9492 vn_decode_VkStructureType(dec, &stype);
9493 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT);
9494
9495 assert(val->sType == stype);
9496 vn_decode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_pnext(dec, val->pNext);
9497 vn_decode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self(dec, val);
9498 }
9499
9500 static inline size_t
vn_sizeof_VkPhysicalDeviceColorWriteEnableFeaturesEXT_pnext_partial(const void * val)9501 vn_sizeof_VkPhysicalDeviceColorWriteEnableFeaturesEXT_pnext_partial(const void *val)
9502 {
9503 /* no known/supported struct */
9504 return vn_sizeof_simple_pointer(NULL);
9505 }
9506
9507 static inline size_t
vn_sizeof_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self_partial(const VkPhysicalDeviceColorWriteEnableFeaturesEXT * val)9508 vn_sizeof_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self_partial(const VkPhysicalDeviceColorWriteEnableFeaturesEXT *val)
9509 {
9510 size_t size = 0;
9511 /* skip val->{sType,pNext} */
9512 /* skip val->colorWriteEnable */
9513 return size;
9514 }
9515
9516 static inline size_t
vn_sizeof_VkPhysicalDeviceColorWriteEnableFeaturesEXT_partial(const VkPhysicalDeviceColorWriteEnableFeaturesEXT * val)9517 vn_sizeof_VkPhysicalDeviceColorWriteEnableFeaturesEXT_partial(const VkPhysicalDeviceColorWriteEnableFeaturesEXT *val)
9518 {
9519 size_t size = 0;
9520
9521 size += vn_sizeof_VkStructureType(&val->sType);
9522 size += vn_sizeof_VkPhysicalDeviceColorWriteEnableFeaturesEXT_pnext_partial(val->pNext);
9523 size += vn_sizeof_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self_partial(val);
9524
9525 return size;
9526 }
9527
9528 static inline void
vn_encode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)9529 vn_encode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9530 {
9531 /* no known/supported struct */
9532 vn_encode_simple_pointer(enc, NULL);
9533 }
9534
9535 static inline void
vn_encode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceColorWriteEnableFeaturesEXT * val)9536 vn_encode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceColorWriteEnableFeaturesEXT *val)
9537 {
9538 /* skip val->{sType,pNext} */
9539 /* skip val->colorWriteEnable */
9540 }
9541
9542 static inline void
vn_encode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceColorWriteEnableFeaturesEXT * val)9543 vn_encode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceColorWriteEnableFeaturesEXT *val)
9544 {
9545 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT);
9546 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT });
9547 vn_encode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_pnext_partial(enc, val->pNext);
9548 vn_encode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self_partial(enc, val);
9549 }
9550
9551 /* struct VkPhysicalDeviceSynchronization2Features chain */
9552
9553 static inline size_t
vn_sizeof_VkPhysicalDeviceSynchronization2Features_pnext(const void * val)9554 vn_sizeof_VkPhysicalDeviceSynchronization2Features_pnext(const void *val)
9555 {
9556 /* no known/supported struct */
9557 return vn_sizeof_simple_pointer(NULL);
9558 }
9559
9560 static inline size_t
vn_sizeof_VkPhysicalDeviceSynchronization2Features_self(const VkPhysicalDeviceSynchronization2Features * val)9561 vn_sizeof_VkPhysicalDeviceSynchronization2Features_self(const VkPhysicalDeviceSynchronization2Features *val)
9562 {
9563 size_t size = 0;
9564 /* skip val->{sType,pNext} */
9565 size += vn_sizeof_VkBool32(&val->synchronization2);
9566 return size;
9567 }
9568
9569 static inline size_t
vn_sizeof_VkPhysicalDeviceSynchronization2Features(const VkPhysicalDeviceSynchronization2Features * val)9570 vn_sizeof_VkPhysicalDeviceSynchronization2Features(const VkPhysicalDeviceSynchronization2Features *val)
9571 {
9572 size_t size = 0;
9573
9574 size += vn_sizeof_VkStructureType(&val->sType);
9575 size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_pnext(val->pNext);
9576 size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_self(val);
9577
9578 return size;
9579 }
9580
9581 static inline void
vn_encode_VkPhysicalDeviceSynchronization2Features_pnext(struct vn_cs_encoder * enc,const void * val)9582 vn_encode_VkPhysicalDeviceSynchronization2Features_pnext(struct vn_cs_encoder *enc, const void *val)
9583 {
9584 /* no known/supported struct */
9585 vn_encode_simple_pointer(enc, NULL);
9586 }
9587
9588 static inline void
vn_encode_VkPhysicalDeviceSynchronization2Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceSynchronization2Features * val)9589 vn_encode_VkPhysicalDeviceSynchronization2Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSynchronization2Features *val)
9590 {
9591 /* skip val->{sType,pNext} */
9592 vn_encode_VkBool32(enc, &val->synchronization2);
9593 }
9594
9595 static inline void
vn_encode_VkPhysicalDeviceSynchronization2Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceSynchronization2Features * val)9596 vn_encode_VkPhysicalDeviceSynchronization2Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceSynchronization2Features *val)
9597 {
9598 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES);
9599 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES });
9600 vn_encode_VkPhysicalDeviceSynchronization2Features_pnext(enc, val->pNext);
9601 vn_encode_VkPhysicalDeviceSynchronization2Features_self(enc, val);
9602 }
9603
9604 static inline void
vn_decode_VkPhysicalDeviceSynchronization2Features_pnext(struct vn_cs_decoder * dec,const void * val)9605 vn_decode_VkPhysicalDeviceSynchronization2Features_pnext(struct vn_cs_decoder *dec, const void *val)
9606 {
9607 /* no known/supported struct */
9608 if (vn_decode_simple_pointer(dec))
9609 assert(false);
9610 }
9611
9612 static inline void
vn_decode_VkPhysicalDeviceSynchronization2Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSynchronization2Features * val)9613 vn_decode_VkPhysicalDeviceSynchronization2Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSynchronization2Features *val)
9614 {
9615 /* skip val->{sType,pNext} */
9616 vn_decode_VkBool32(dec, &val->synchronization2);
9617 }
9618
9619 static inline void
vn_decode_VkPhysicalDeviceSynchronization2Features(struct vn_cs_decoder * dec,VkPhysicalDeviceSynchronization2Features * val)9620 vn_decode_VkPhysicalDeviceSynchronization2Features(struct vn_cs_decoder *dec, VkPhysicalDeviceSynchronization2Features *val)
9621 {
9622 VkStructureType stype;
9623 vn_decode_VkStructureType(dec, &stype);
9624 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES);
9625
9626 assert(val->sType == stype);
9627 vn_decode_VkPhysicalDeviceSynchronization2Features_pnext(dec, val->pNext);
9628 vn_decode_VkPhysicalDeviceSynchronization2Features_self(dec, val);
9629 }
9630
9631 static inline size_t
vn_sizeof_VkPhysicalDeviceSynchronization2Features_pnext_partial(const void * val)9632 vn_sizeof_VkPhysicalDeviceSynchronization2Features_pnext_partial(const void *val)
9633 {
9634 /* no known/supported struct */
9635 return vn_sizeof_simple_pointer(NULL);
9636 }
9637
9638 static inline size_t
vn_sizeof_VkPhysicalDeviceSynchronization2Features_self_partial(const VkPhysicalDeviceSynchronization2Features * val)9639 vn_sizeof_VkPhysicalDeviceSynchronization2Features_self_partial(const VkPhysicalDeviceSynchronization2Features *val)
9640 {
9641 size_t size = 0;
9642 /* skip val->{sType,pNext} */
9643 /* skip val->synchronization2 */
9644 return size;
9645 }
9646
9647 static inline size_t
vn_sizeof_VkPhysicalDeviceSynchronization2Features_partial(const VkPhysicalDeviceSynchronization2Features * val)9648 vn_sizeof_VkPhysicalDeviceSynchronization2Features_partial(const VkPhysicalDeviceSynchronization2Features *val)
9649 {
9650 size_t size = 0;
9651
9652 size += vn_sizeof_VkStructureType(&val->sType);
9653 size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_pnext_partial(val->pNext);
9654 size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_self_partial(val);
9655
9656 return size;
9657 }
9658
9659 static inline void
vn_encode_VkPhysicalDeviceSynchronization2Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)9660 vn_encode_VkPhysicalDeviceSynchronization2Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9661 {
9662 /* no known/supported struct */
9663 vn_encode_simple_pointer(enc, NULL);
9664 }
9665
9666 static inline void
vn_encode_VkPhysicalDeviceSynchronization2Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSynchronization2Features * val)9667 vn_encode_VkPhysicalDeviceSynchronization2Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSynchronization2Features *val)
9668 {
9669 /* skip val->{sType,pNext} */
9670 /* skip val->synchronization2 */
9671 }
9672
9673 static inline void
vn_encode_VkPhysicalDeviceSynchronization2Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSynchronization2Features * val)9674 vn_encode_VkPhysicalDeviceSynchronization2Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSynchronization2Features *val)
9675 {
9676 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES);
9677 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES });
9678 vn_encode_VkPhysicalDeviceSynchronization2Features_pnext_partial(enc, val->pNext);
9679 vn_encode_VkPhysicalDeviceSynchronization2Features_self_partial(enc, val);
9680 }
9681
9682 /* struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT chain */
9683
9684 static inline size_t
vn_sizeof_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_pnext(const void * val)9685 vn_sizeof_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_pnext(const void *val)
9686 {
9687 /* no known/supported struct */
9688 return vn_sizeof_simple_pointer(NULL);
9689 }
9690
9691 static inline size_t
vn_sizeof_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self(const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT * val)9692 vn_sizeof_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self(const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *val)
9693 {
9694 size_t size = 0;
9695 /* skip val->{sType,pNext} */
9696 size += vn_sizeof_VkBool32(&val->primitivesGeneratedQuery);
9697 size += vn_sizeof_VkBool32(&val->primitivesGeneratedQueryWithRasterizerDiscard);
9698 size += vn_sizeof_VkBool32(&val->primitivesGeneratedQueryWithNonZeroStreams);
9699 return size;
9700 }
9701
9702 static inline size_t
vn_sizeof_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT * val)9703 vn_sizeof_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *val)
9704 {
9705 size_t size = 0;
9706
9707 size += vn_sizeof_VkStructureType(&val->sType);
9708 size += vn_sizeof_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_pnext(val->pNext);
9709 size += vn_sizeof_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self(val);
9710
9711 return size;
9712 }
9713
9714 static inline void
vn_encode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)9715 vn_encode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
9716 {
9717 /* no known/supported struct */
9718 vn_encode_simple_pointer(enc, NULL);
9719 }
9720
9721 static inline void
vn_encode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT * val)9722 vn_encode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *val)
9723 {
9724 /* skip val->{sType,pNext} */
9725 vn_encode_VkBool32(enc, &val->primitivesGeneratedQuery);
9726 vn_encode_VkBool32(enc, &val->primitivesGeneratedQueryWithRasterizerDiscard);
9727 vn_encode_VkBool32(enc, &val->primitivesGeneratedQueryWithNonZeroStreams);
9728 }
9729
9730 static inline void
vn_encode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT * val)9731 vn_encode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *val)
9732 {
9733 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT);
9734 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT });
9735 vn_encode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_pnext(enc, val->pNext);
9736 vn_encode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self(enc, val);
9737 }
9738
9739 static inline void
vn_decode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)9740 vn_decode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
9741 {
9742 /* no known/supported struct */
9743 if (vn_decode_simple_pointer(dec))
9744 assert(false);
9745 }
9746
9747 static inline void
vn_decode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT * val)9748 vn_decode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *val)
9749 {
9750 /* skip val->{sType,pNext} */
9751 vn_decode_VkBool32(dec, &val->primitivesGeneratedQuery);
9752 vn_decode_VkBool32(dec, &val->primitivesGeneratedQueryWithRasterizerDiscard);
9753 vn_decode_VkBool32(dec, &val->primitivesGeneratedQueryWithNonZeroStreams);
9754 }
9755
9756 static inline void
vn_decode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT * val)9757 vn_decode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *val)
9758 {
9759 VkStructureType stype;
9760 vn_decode_VkStructureType(dec, &stype);
9761 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT);
9762
9763 assert(val->sType == stype);
9764 vn_decode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_pnext(dec, val->pNext);
9765 vn_decode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self(dec, val);
9766 }
9767
9768 static inline size_t
vn_sizeof_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_pnext_partial(const void * val)9769 vn_sizeof_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_pnext_partial(const void *val)
9770 {
9771 /* no known/supported struct */
9772 return vn_sizeof_simple_pointer(NULL);
9773 }
9774
9775 static inline size_t
vn_sizeof_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self_partial(const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT * val)9776 vn_sizeof_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self_partial(const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *val)
9777 {
9778 size_t size = 0;
9779 /* skip val->{sType,pNext} */
9780 /* skip val->primitivesGeneratedQuery */
9781 /* skip val->primitivesGeneratedQueryWithRasterizerDiscard */
9782 /* skip val->primitivesGeneratedQueryWithNonZeroStreams */
9783 return size;
9784 }
9785
9786 static inline size_t
vn_sizeof_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_partial(const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT * val)9787 vn_sizeof_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_partial(const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *val)
9788 {
9789 size_t size = 0;
9790
9791 size += vn_sizeof_VkStructureType(&val->sType);
9792 size += vn_sizeof_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_pnext_partial(val->pNext);
9793 size += vn_sizeof_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self_partial(val);
9794
9795 return size;
9796 }
9797
9798 static inline void
vn_encode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)9799 vn_encode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9800 {
9801 /* no known/supported struct */
9802 vn_encode_simple_pointer(enc, NULL);
9803 }
9804
9805 static inline void
vn_encode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT * val)9806 vn_encode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *val)
9807 {
9808 /* skip val->{sType,pNext} */
9809 /* skip val->primitivesGeneratedQuery */
9810 /* skip val->primitivesGeneratedQueryWithRasterizerDiscard */
9811 /* skip val->primitivesGeneratedQueryWithNonZeroStreams */
9812 }
9813
9814 static inline void
vn_encode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT * val)9815 vn_encode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *val)
9816 {
9817 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT);
9818 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT });
9819 vn_encode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_pnext_partial(enc, val->pNext);
9820 vn_encode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self_partial(enc, val);
9821 }
9822
9823 /* struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT chain */
9824
9825 static inline size_t
vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(const void * val)9826 vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(const void *val)
9827 {
9828 /* no known/supported struct */
9829 return vn_sizeof_simple_pointer(NULL);
9830 }
9831
9832 static inline size_t
vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)9833 vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
9834 {
9835 size_t size = 0;
9836 /* skip val->{sType,pNext} */
9837 size += vn_sizeof_VkBool32(&val->ycbcr2plane444Formats);
9838 return size;
9839 }
9840
9841 static inline size_t
vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)9842 vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
9843 {
9844 size_t size = 0;
9845
9846 size += vn_sizeof_VkStructureType(&val->sType);
9847 size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(val->pNext);
9848 size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(val);
9849
9850 return size;
9851 }
9852
9853 static inline void
vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)9854 vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
9855 {
9856 /* no known/supported struct */
9857 vn_encode_simple_pointer(enc, NULL);
9858 }
9859
9860 static inline void
vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)9861 vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
9862 {
9863 /* skip val->{sType,pNext} */
9864 vn_encode_VkBool32(enc, &val->ycbcr2plane444Formats);
9865 }
9866
9867 static inline void
vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)9868 vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
9869 {
9870 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT);
9871 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT });
9872 vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(enc, val->pNext);
9873 vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(enc, val);
9874 }
9875
9876 static inline void
vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)9877 vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
9878 {
9879 /* no known/supported struct */
9880 if (vn_decode_simple_pointer(dec))
9881 assert(false);
9882 }
9883
9884 static inline void
vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)9885 vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
9886 {
9887 /* skip val->{sType,pNext} */
9888 vn_decode_VkBool32(dec, &val->ycbcr2plane444Formats);
9889 }
9890
9891 static inline void
vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)9892 vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
9893 {
9894 VkStructureType stype;
9895 vn_decode_VkStructureType(dec, &stype);
9896 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT);
9897
9898 assert(val->sType == stype);
9899 vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(dec, val->pNext);
9900 vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(dec, val);
9901 }
9902
9903 static inline size_t
vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext_partial(const void * val)9904 vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext_partial(const void *val)
9905 {
9906 /* no known/supported struct */
9907 return vn_sizeof_simple_pointer(NULL);
9908 }
9909
9910 static inline size_t
vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)9911 vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
9912 {
9913 size_t size = 0;
9914 /* skip val->{sType,pNext} */
9915 /* skip val->ycbcr2plane444Formats */
9916 return size;
9917 }
9918
9919 static inline size_t
vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_partial(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)9920 vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_partial(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
9921 {
9922 size_t size = 0;
9923
9924 size += vn_sizeof_VkStructureType(&val->sType);
9925 size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext_partial(val->pNext);
9926 size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial(val);
9927
9928 return size;
9929 }
9930
9931 static inline void
vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)9932 vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9933 {
9934 /* no known/supported struct */
9935 vn_encode_simple_pointer(enc, NULL);
9936 }
9937
9938 static inline void
vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)9939 vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
9940 {
9941 /* skip val->{sType,pNext} */
9942 /* skip val->ycbcr2plane444Formats */
9943 }
9944
9945 static inline void
vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)9946 vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
9947 {
9948 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT);
9949 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT });
9950 vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext_partial(enc, val->pNext);
9951 vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial(enc, val);
9952 }
9953
9954 /* struct VkPhysicalDeviceProvokingVertexFeaturesEXT chain */
9955
9956 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext(const void * val)9957 vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext(const void *val)
9958 {
9959 /* no known/supported struct */
9960 return vn_sizeof_simple_pointer(NULL);
9961 }
9962
9963 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(const VkPhysicalDeviceProvokingVertexFeaturesEXT * val)9964 vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(const VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
9965 {
9966 size_t size = 0;
9967 /* skip val->{sType,pNext} */
9968 size += vn_sizeof_VkBool32(&val->provokingVertexLast);
9969 size += vn_sizeof_VkBool32(&val->transformFeedbackPreservesProvokingVertex);
9970 return size;
9971 }
9972
9973 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT(const VkPhysicalDeviceProvokingVertexFeaturesEXT * val)9974 vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT(const VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
9975 {
9976 size_t size = 0;
9977
9978 size += vn_sizeof_VkStructureType(&val->sType);
9979 size += vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext(val->pNext);
9980 size += vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(val);
9981
9982 return size;
9983 }
9984
9985 static inline void
vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)9986 vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
9987 {
9988 /* no known/supported struct */
9989 vn_encode_simple_pointer(enc, NULL);
9990 }
9991
9992 static inline void
vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceProvokingVertexFeaturesEXT * val)9993 vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
9994 {
9995 /* skip val->{sType,pNext} */
9996 vn_encode_VkBool32(enc, &val->provokingVertexLast);
9997 vn_encode_VkBool32(enc, &val->transformFeedbackPreservesProvokingVertex);
9998 }
9999
10000 static inline void
vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceProvokingVertexFeaturesEXT * val)10001 vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
10002 {
10003 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT);
10004 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT });
10005 vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext(enc, val->pNext);
10006 vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(enc, val);
10007 }
10008
10009 static inline void
vn_decode_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)10010 vn_decode_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
10011 {
10012 /* no known/supported struct */
10013 if (vn_decode_simple_pointer(dec))
10014 assert(false);
10015 }
10016
10017 static inline void
vn_decode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceProvokingVertexFeaturesEXT * val)10018 vn_decode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
10019 {
10020 /* skip val->{sType,pNext} */
10021 vn_decode_VkBool32(dec, &val->provokingVertexLast);
10022 vn_decode_VkBool32(dec, &val->transformFeedbackPreservesProvokingVertex);
10023 }
10024
10025 static inline void
vn_decode_VkPhysicalDeviceProvokingVertexFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceProvokingVertexFeaturesEXT * val)10026 vn_decode_VkPhysicalDeviceProvokingVertexFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
10027 {
10028 VkStructureType stype;
10029 vn_decode_VkStructureType(dec, &stype);
10030 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT);
10031
10032 assert(val->sType == stype);
10033 vn_decode_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext(dec, val->pNext);
10034 vn_decode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(dec, val);
10035 }
10036
10037 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext_partial(const void * val)10038 vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext_partial(const void *val)
10039 {
10040 /* no known/supported struct */
10041 return vn_sizeof_simple_pointer(NULL);
10042 }
10043
10044 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_self_partial(const VkPhysicalDeviceProvokingVertexFeaturesEXT * val)10045 vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_self_partial(const VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
10046 {
10047 size_t size = 0;
10048 /* skip val->{sType,pNext} */
10049 /* skip val->provokingVertexLast */
10050 /* skip val->transformFeedbackPreservesProvokingVertex */
10051 return size;
10052 }
10053
10054 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_partial(const VkPhysicalDeviceProvokingVertexFeaturesEXT * val)10055 vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_partial(const VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
10056 {
10057 size_t size = 0;
10058
10059 size += vn_sizeof_VkStructureType(&val->sType);
10060 size += vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext_partial(val->pNext);
10061 size += vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_self_partial(val);
10062
10063 return size;
10064 }
10065
10066 static inline void
vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)10067 vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
10068 {
10069 /* no known/supported struct */
10070 vn_encode_simple_pointer(enc, NULL);
10071 }
10072
10073 static inline void
vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProvokingVertexFeaturesEXT * val)10074 vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
10075 {
10076 /* skip val->{sType,pNext} */
10077 /* skip val->provokingVertexLast */
10078 /* skip val->transformFeedbackPreservesProvokingVertex */
10079 }
10080
10081 static inline void
vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProvokingVertexFeaturesEXT * val)10082 vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
10083 {
10084 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT);
10085 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT });
10086 vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext_partial(enc, val->pNext);
10087 vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self_partial(enc, val);
10088 }
10089
10090 /* struct VkPhysicalDeviceShaderIntegerDotProductFeatures chain */
10091
10092 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(const void * val)10093 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(const void *val)
10094 {
10095 /* no known/supported struct */
10096 return vn_sizeof_simple_pointer(NULL);
10097 }
10098
10099 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(const VkPhysicalDeviceShaderIntegerDotProductFeatures * val)10100 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(const VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
10101 {
10102 size_t size = 0;
10103 /* skip val->{sType,pNext} */
10104 size += vn_sizeof_VkBool32(&val->shaderIntegerDotProduct);
10105 return size;
10106 }
10107
10108 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures(const VkPhysicalDeviceShaderIntegerDotProductFeatures * val)10109 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures(const VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
10110 {
10111 size_t size = 0;
10112
10113 size += vn_sizeof_VkStructureType(&val->sType);
10114 size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(val->pNext);
10115 size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(val);
10116
10117 return size;
10118 }
10119
10120 static inline void
vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(struct vn_cs_encoder * enc,const void * val)10121 vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
10122 {
10123 /* no known/supported struct */
10124 vn_encode_simple_pointer(enc, NULL);
10125 }
10126
10127 static inline void
vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderIntegerDotProductFeatures * val)10128 vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
10129 {
10130 /* skip val->{sType,pNext} */
10131 vn_encode_VkBool32(enc, &val->shaderIntegerDotProduct);
10132 }
10133
10134 static inline void
vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderIntegerDotProductFeatures * val)10135 vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
10136 {
10137 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES);
10138 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES });
10139 vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(enc, val->pNext);
10140 vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(enc, val);
10141 }
10142
10143 static inline void
vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(struct vn_cs_decoder * dec,const void * val)10144 vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
10145 {
10146 /* no known/supported struct */
10147 if (vn_decode_simple_pointer(dec))
10148 assert(false);
10149 }
10150
10151 static inline void
vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderIntegerDotProductFeatures * val)10152 vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
10153 {
10154 /* skip val->{sType,pNext} */
10155 vn_decode_VkBool32(dec, &val->shaderIntegerDotProduct);
10156 }
10157
10158 static inline void
vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderIntegerDotProductFeatures * val)10159 vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
10160 {
10161 VkStructureType stype;
10162 vn_decode_VkStructureType(dec, &stype);
10163 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES);
10164
10165 assert(val->sType == stype);
10166 vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(dec, val->pNext);
10167 vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(dec, val);
10168 }
10169
10170 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext_partial(const void * val)10171 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext_partial(const void *val)
10172 {
10173 /* no known/supported struct */
10174 return vn_sizeof_simple_pointer(NULL);
10175 }
10176
10177 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial(const VkPhysicalDeviceShaderIntegerDotProductFeatures * val)10178 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial(const VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
10179 {
10180 size_t size = 0;
10181 /* skip val->{sType,pNext} */
10182 /* skip val->shaderIntegerDotProduct */
10183 return size;
10184 }
10185
10186 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_partial(const VkPhysicalDeviceShaderIntegerDotProductFeatures * val)10187 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_partial(const VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
10188 {
10189 size_t size = 0;
10190
10191 size += vn_sizeof_VkStructureType(&val->sType);
10192 size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext_partial(val->pNext);
10193 size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial(val);
10194
10195 return size;
10196 }
10197
10198 static inline void
vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)10199 vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
10200 {
10201 /* no known/supported struct */
10202 vn_encode_simple_pointer(enc, NULL);
10203 }
10204
10205 static inline void
vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderIntegerDotProductFeatures * val)10206 vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
10207 {
10208 /* skip val->{sType,pNext} */
10209 /* skip val->shaderIntegerDotProduct */
10210 }
10211
10212 static inline void
vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderIntegerDotProductFeatures * val)10213 vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
10214 {
10215 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES);
10216 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES });
10217 vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext_partial(enc, val->pNext);
10218 vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial(enc, val);
10219 }
10220
10221 /* struct VkPhysicalDeviceDynamicRenderingFeatures chain */
10222
10223 static inline size_t
vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_pnext(const void * val)10224 vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_pnext(const void *val)
10225 {
10226 /* no known/supported struct */
10227 return vn_sizeof_simple_pointer(NULL);
10228 }
10229
10230 static inline size_t
vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self(const VkPhysicalDeviceDynamicRenderingFeatures * val)10231 vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self(const VkPhysicalDeviceDynamicRenderingFeatures *val)
10232 {
10233 size_t size = 0;
10234 /* skip val->{sType,pNext} */
10235 size += vn_sizeof_VkBool32(&val->dynamicRendering);
10236 return size;
10237 }
10238
10239 static inline size_t
vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures(const VkPhysicalDeviceDynamicRenderingFeatures * val)10240 vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures(const VkPhysicalDeviceDynamicRenderingFeatures *val)
10241 {
10242 size_t size = 0;
10243
10244 size += vn_sizeof_VkStructureType(&val->sType);
10245 size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_pnext(val->pNext);
10246 size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self(val);
10247
10248 return size;
10249 }
10250
10251 static inline void
vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_pnext(struct vn_cs_encoder * enc,const void * val)10252 vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
10253 {
10254 /* no known/supported struct */
10255 vn_encode_simple_pointer(enc, NULL);
10256 }
10257
10258 static inline void
vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceDynamicRenderingFeatures * val)10259 vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceDynamicRenderingFeatures *val)
10260 {
10261 /* skip val->{sType,pNext} */
10262 vn_encode_VkBool32(enc, &val->dynamicRendering);
10263 }
10264
10265 static inline void
vn_encode_VkPhysicalDeviceDynamicRenderingFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceDynamicRenderingFeatures * val)10266 vn_encode_VkPhysicalDeviceDynamicRenderingFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceDynamicRenderingFeatures *val)
10267 {
10268 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES);
10269 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES });
10270 vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_pnext(enc, val->pNext);
10271 vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self(enc, val);
10272 }
10273
10274 static inline void
vn_decode_VkPhysicalDeviceDynamicRenderingFeatures_pnext(struct vn_cs_decoder * dec,const void * val)10275 vn_decode_VkPhysicalDeviceDynamicRenderingFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
10276 {
10277 /* no known/supported struct */
10278 if (vn_decode_simple_pointer(dec))
10279 assert(false);
10280 }
10281
10282 static inline void
vn_decode_VkPhysicalDeviceDynamicRenderingFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDynamicRenderingFeatures * val)10283 vn_decode_VkPhysicalDeviceDynamicRenderingFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDynamicRenderingFeatures *val)
10284 {
10285 /* skip val->{sType,pNext} */
10286 vn_decode_VkBool32(dec, &val->dynamicRendering);
10287 }
10288
10289 static inline void
vn_decode_VkPhysicalDeviceDynamicRenderingFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceDynamicRenderingFeatures * val)10290 vn_decode_VkPhysicalDeviceDynamicRenderingFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceDynamicRenderingFeatures *val)
10291 {
10292 VkStructureType stype;
10293 vn_decode_VkStructureType(dec, &stype);
10294 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES);
10295
10296 assert(val->sType == stype);
10297 vn_decode_VkPhysicalDeviceDynamicRenderingFeatures_pnext(dec, val->pNext);
10298 vn_decode_VkPhysicalDeviceDynamicRenderingFeatures_self(dec, val);
10299 }
10300
10301 static inline size_t
vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_pnext_partial(const void * val)10302 vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_pnext_partial(const void *val)
10303 {
10304 /* no known/supported struct */
10305 return vn_sizeof_simple_pointer(NULL);
10306 }
10307
10308 static inline size_t
vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self_partial(const VkPhysicalDeviceDynamicRenderingFeatures * val)10309 vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self_partial(const VkPhysicalDeviceDynamicRenderingFeatures *val)
10310 {
10311 size_t size = 0;
10312 /* skip val->{sType,pNext} */
10313 /* skip val->dynamicRendering */
10314 return size;
10315 }
10316
10317 static inline size_t
vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_partial(const VkPhysicalDeviceDynamicRenderingFeatures * val)10318 vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_partial(const VkPhysicalDeviceDynamicRenderingFeatures *val)
10319 {
10320 size_t size = 0;
10321
10322 size += vn_sizeof_VkStructureType(&val->sType);
10323 size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_pnext_partial(val->pNext);
10324 size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self_partial(val);
10325
10326 return size;
10327 }
10328
10329 static inline void
vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)10330 vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
10331 {
10332 /* no known/supported struct */
10333 vn_encode_simple_pointer(enc, NULL);
10334 }
10335
10336 static inline void
vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDynamicRenderingFeatures * val)10337 vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDynamicRenderingFeatures *val)
10338 {
10339 /* skip val->{sType,pNext} */
10340 /* skip val->dynamicRendering */
10341 }
10342
10343 static inline void
vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDynamicRenderingFeatures * val)10344 vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDynamicRenderingFeatures *val)
10345 {
10346 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES);
10347 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES });
10348 vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_pnext_partial(enc, val->pNext);
10349 vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self_partial(enc, val);
10350 }
10351
10352 /* struct VkPhysicalDeviceImageViewMinLodFeaturesEXT chain */
10353
10354 static inline size_t
vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext(const void * val)10355 vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext(const void *val)
10356 {
10357 /* no known/supported struct */
10358 return vn_sizeof_simple_pointer(NULL);
10359 }
10360
10361 static inline size_t
vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(const VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)10362 vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(const VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
10363 {
10364 size_t size = 0;
10365 /* skip val->{sType,pNext} */
10366 size += vn_sizeof_VkBool32(&val->minLod);
10367 return size;
10368 }
10369
10370 static inline size_t
vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT(const VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)10371 vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT(const VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
10372 {
10373 size_t size = 0;
10374
10375 size += vn_sizeof_VkStructureType(&val->sType);
10376 size += vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext(val->pNext);
10377 size += vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(val);
10378
10379 return size;
10380 }
10381
10382 static inline void
vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)10383 vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
10384 {
10385 /* no known/supported struct */
10386 vn_encode_simple_pointer(enc, NULL);
10387 }
10388
10389 static inline void
vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)10390 vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
10391 {
10392 /* skip val->{sType,pNext} */
10393 vn_encode_VkBool32(enc, &val->minLod);
10394 }
10395
10396 static inline void
vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)10397 vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
10398 {
10399 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT);
10400 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT });
10401 vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext(enc, val->pNext);
10402 vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(enc, val);
10403 }
10404
10405 static inline void
vn_decode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)10406 vn_decode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
10407 {
10408 /* no known/supported struct */
10409 if (vn_decode_simple_pointer(dec))
10410 assert(false);
10411 }
10412
10413 static inline void
vn_decode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)10414 vn_decode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
10415 {
10416 /* skip val->{sType,pNext} */
10417 vn_decode_VkBool32(dec, &val->minLod);
10418 }
10419
10420 static inline void
vn_decode_VkPhysicalDeviceImageViewMinLodFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)10421 vn_decode_VkPhysicalDeviceImageViewMinLodFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
10422 {
10423 VkStructureType stype;
10424 vn_decode_VkStructureType(dec, &stype);
10425 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT);
10426
10427 assert(val->sType == stype);
10428 vn_decode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext(dec, val->pNext);
10429 vn_decode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(dec, val);
10430 }
10431
10432 static inline size_t
vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext_partial(const void * val)10433 vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext_partial(const void *val)
10434 {
10435 /* no known/supported struct */
10436 return vn_sizeof_simple_pointer(NULL);
10437 }
10438
10439 static inline size_t
vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self_partial(const VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)10440 vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self_partial(const VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
10441 {
10442 size_t size = 0;
10443 /* skip val->{sType,pNext} */
10444 /* skip val->minLod */
10445 return size;
10446 }
10447
10448 static inline size_t
vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_partial(const VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)10449 vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_partial(const VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
10450 {
10451 size_t size = 0;
10452
10453 size += vn_sizeof_VkStructureType(&val->sType);
10454 size += vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext_partial(val->pNext);
10455 size += vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self_partial(val);
10456
10457 return size;
10458 }
10459
10460 static inline void
vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)10461 vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
10462 {
10463 /* no known/supported struct */
10464 vn_encode_simple_pointer(enc, NULL);
10465 }
10466
10467 static inline void
vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)10468 vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
10469 {
10470 /* skip val->{sType,pNext} */
10471 /* skip val->minLod */
10472 }
10473
10474 static inline void
vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)10475 vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
10476 {
10477 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT);
10478 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT });
10479 vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext_partial(enc, val->pNext);
10480 vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self_partial(enc, val);
10481 }
10482
10483 /* struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT chain */
10484
10485 static inline size_t
vn_sizeof_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_pnext(const void * val)10486 vn_sizeof_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_pnext(const void *val)
10487 {
10488 /* no known/supported struct */
10489 return vn_sizeof_simple_pointer(NULL);
10490 }
10491
10492 static inline size_t
vn_sizeof_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self(const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT * val)10493 vn_sizeof_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self(const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *val)
10494 {
10495 size_t size = 0;
10496 /* skip val->{sType,pNext} */
10497 size += vn_sizeof_VkBool32(&val->rasterizationOrderColorAttachmentAccess);
10498 size += vn_sizeof_VkBool32(&val->rasterizationOrderDepthAttachmentAccess);
10499 size += vn_sizeof_VkBool32(&val->rasterizationOrderStencilAttachmentAccess);
10500 return size;
10501 }
10502
10503 static inline size_t
vn_sizeof_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT * val)10504 vn_sizeof_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *val)
10505 {
10506 size_t size = 0;
10507
10508 size += vn_sizeof_VkStructureType(&val->sType);
10509 size += vn_sizeof_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_pnext(val->pNext);
10510 size += vn_sizeof_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self(val);
10511
10512 return size;
10513 }
10514
10515 static inline void
vn_encode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)10516 vn_encode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
10517 {
10518 /* no known/supported struct */
10519 vn_encode_simple_pointer(enc, NULL);
10520 }
10521
10522 static inline void
vn_encode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT * val)10523 vn_encode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *val)
10524 {
10525 /* skip val->{sType,pNext} */
10526 vn_encode_VkBool32(enc, &val->rasterizationOrderColorAttachmentAccess);
10527 vn_encode_VkBool32(enc, &val->rasterizationOrderDepthAttachmentAccess);
10528 vn_encode_VkBool32(enc, &val->rasterizationOrderStencilAttachmentAccess);
10529 }
10530
10531 static inline void
vn_encode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT * val)10532 vn_encode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *val)
10533 {
10534 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT);
10535 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT });
10536 vn_encode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_pnext(enc, val->pNext);
10537 vn_encode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self(enc, val);
10538 }
10539
10540 static inline void
vn_decode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)10541 vn_decode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
10542 {
10543 /* no known/supported struct */
10544 if (vn_decode_simple_pointer(dec))
10545 assert(false);
10546 }
10547
10548 static inline void
vn_decode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT * val)10549 vn_decode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *val)
10550 {
10551 /* skip val->{sType,pNext} */
10552 vn_decode_VkBool32(dec, &val->rasterizationOrderColorAttachmentAccess);
10553 vn_decode_VkBool32(dec, &val->rasterizationOrderDepthAttachmentAccess);
10554 vn_decode_VkBool32(dec, &val->rasterizationOrderStencilAttachmentAccess);
10555 }
10556
10557 static inline void
vn_decode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT * val)10558 vn_decode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *val)
10559 {
10560 VkStructureType stype;
10561 vn_decode_VkStructureType(dec, &stype);
10562 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT);
10563
10564 assert(val->sType == stype);
10565 vn_decode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_pnext(dec, val->pNext);
10566 vn_decode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self(dec, val);
10567 }
10568
10569 static inline size_t
vn_sizeof_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_pnext_partial(const void * val)10570 vn_sizeof_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_pnext_partial(const void *val)
10571 {
10572 /* no known/supported struct */
10573 return vn_sizeof_simple_pointer(NULL);
10574 }
10575
10576 static inline size_t
vn_sizeof_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self_partial(const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT * val)10577 vn_sizeof_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self_partial(const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *val)
10578 {
10579 size_t size = 0;
10580 /* skip val->{sType,pNext} */
10581 /* skip val->rasterizationOrderColorAttachmentAccess */
10582 /* skip val->rasterizationOrderDepthAttachmentAccess */
10583 /* skip val->rasterizationOrderStencilAttachmentAccess */
10584 return size;
10585 }
10586
10587 static inline size_t
vn_sizeof_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_partial(const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT * val)10588 vn_sizeof_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_partial(const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *val)
10589 {
10590 size_t size = 0;
10591
10592 size += vn_sizeof_VkStructureType(&val->sType);
10593 size += vn_sizeof_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_pnext_partial(val->pNext);
10594 size += vn_sizeof_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self_partial(val);
10595
10596 return size;
10597 }
10598
10599 static inline void
vn_encode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)10600 vn_encode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
10601 {
10602 /* no known/supported struct */
10603 vn_encode_simple_pointer(enc, NULL);
10604 }
10605
10606 static inline void
vn_encode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT * val)10607 vn_encode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *val)
10608 {
10609 /* skip val->{sType,pNext} */
10610 /* skip val->rasterizationOrderColorAttachmentAccess */
10611 /* skip val->rasterizationOrderDepthAttachmentAccess */
10612 /* skip val->rasterizationOrderStencilAttachmentAccess */
10613 }
10614
10615 static inline void
vn_encode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT * val)10616 vn_encode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *val)
10617 {
10618 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT);
10619 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT });
10620 vn_encode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_pnext_partial(enc, val->pNext);
10621 vn_encode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self_partial(enc, val);
10622 }
10623
10624 /* struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT chain */
10625
10626 static inline size_t
vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_pnext(const void * val)10627 vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_pnext(const void *val)
10628 {
10629 /* no known/supported struct */
10630 return vn_sizeof_simple_pointer(NULL);
10631 }
10632
10633 static inline size_t
vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self(const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT * val)10634 vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self(const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *val)
10635 {
10636 size_t size = 0;
10637 /* skip val->{sType,pNext} */
10638 size += vn_sizeof_VkBool32(&val->graphicsPipelineLibrary);
10639 return size;
10640 }
10641
10642 static inline size_t
vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT * val)10643 vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *val)
10644 {
10645 size_t size = 0;
10646
10647 size += vn_sizeof_VkStructureType(&val->sType);
10648 size += vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_pnext(val->pNext);
10649 size += vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self(val);
10650
10651 return size;
10652 }
10653
10654 static inline void
vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)10655 vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
10656 {
10657 /* no known/supported struct */
10658 vn_encode_simple_pointer(enc, NULL);
10659 }
10660
10661 static inline void
vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT * val)10662 vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *val)
10663 {
10664 /* skip val->{sType,pNext} */
10665 vn_encode_VkBool32(enc, &val->graphicsPipelineLibrary);
10666 }
10667
10668 static inline void
vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT * val)10669 vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *val)
10670 {
10671 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT);
10672 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT });
10673 vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_pnext(enc, val->pNext);
10674 vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self(enc, val);
10675 }
10676
10677 static inline void
vn_decode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)10678 vn_decode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
10679 {
10680 /* no known/supported struct */
10681 if (vn_decode_simple_pointer(dec))
10682 assert(false);
10683 }
10684
10685 static inline void
vn_decode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT * val)10686 vn_decode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *val)
10687 {
10688 /* skip val->{sType,pNext} */
10689 vn_decode_VkBool32(dec, &val->graphicsPipelineLibrary);
10690 }
10691
10692 static inline void
vn_decode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT * val)10693 vn_decode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *val)
10694 {
10695 VkStructureType stype;
10696 vn_decode_VkStructureType(dec, &stype);
10697 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT);
10698
10699 assert(val->sType == stype);
10700 vn_decode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_pnext(dec, val->pNext);
10701 vn_decode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self(dec, val);
10702 }
10703
10704 static inline size_t
vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_pnext_partial(const void * val)10705 vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_pnext_partial(const void *val)
10706 {
10707 /* no known/supported struct */
10708 return vn_sizeof_simple_pointer(NULL);
10709 }
10710
10711 static inline size_t
vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self_partial(const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT * val)10712 vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self_partial(const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *val)
10713 {
10714 size_t size = 0;
10715 /* skip val->{sType,pNext} */
10716 /* skip val->graphicsPipelineLibrary */
10717 return size;
10718 }
10719
10720 static inline size_t
vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_partial(const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT * val)10721 vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_partial(const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *val)
10722 {
10723 size_t size = 0;
10724
10725 size += vn_sizeof_VkStructureType(&val->sType);
10726 size += vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_pnext_partial(val->pNext);
10727 size += vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self_partial(val);
10728
10729 return size;
10730 }
10731
10732 static inline void
vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)10733 vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
10734 {
10735 /* no known/supported struct */
10736 vn_encode_simple_pointer(enc, NULL);
10737 }
10738
10739 static inline void
vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT * val)10740 vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *val)
10741 {
10742 /* skip val->{sType,pNext} */
10743 /* skip val->graphicsPipelineLibrary */
10744 }
10745
10746 static inline void
vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT * val)10747 vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *val)
10748 {
10749 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT);
10750 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT });
10751 vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_pnext_partial(enc, val->pNext);
10752 vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self_partial(enc, val);
10753 }
10754
10755 /* struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT chain */
10756
10757 static inline size_t
vn_sizeof_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_pnext(const void * val)10758 vn_sizeof_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_pnext(const void *val)
10759 {
10760 /* no known/supported struct */
10761 return vn_sizeof_simple_pointer(NULL);
10762 }
10763
10764 static inline size_t
vn_sizeof_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT * val)10765 vn_sizeof_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *val)
10766 {
10767 size_t size = 0;
10768 /* skip val->{sType,pNext} */
10769 size += vn_sizeof_VkBool32(&val->nonSeamlessCubeMap);
10770 return size;
10771 }
10772
10773 static inline size_t
vn_sizeof_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT * val)10774 vn_sizeof_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *val)
10775 {
10776 size_t size = 0;
10777
10778 size += vn_sizeof_VkStructureType(&val->sType);
10779 size += vn_sizeof_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_pnext(val->pNext);
10780 size += vn_sizeof_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self(val);
10781
10782 return size;
10783 }
10784
10785 static inline void
vn_encode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)10786 vn_encode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
10787 {
10788 /* no known/supported struct */
10789 vn_encode_simple_pointer(enc, NULL);
10790 }
10791
10792 static inline void
vn_encode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT * val)10793 vn_encode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *val)
10794 {
10795 /* skip val->{sType,pNext} */
10796 vn_encode_VkBool32(enc, &val->nonSeamlessCubeMap);
10797 }
10798
10799 static inline void
vn_encode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT * val)10800 vn_encode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *val)
10801 {
10802 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT);
10803 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT });
10804 vn_encode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_pnext(enc, val->pNext);
10805 vn_encode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self(enc, val);
10806 }
10807
10808 static inline void
vn_decode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)10809 vn_decode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
10810 {
10811 /* no known/supported struct */
10812 if (vn_decode_simple_pointer(dec))
10813 assert(false);
10814 }
10815
10816 static inline void
vn_decode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT * val)10817 vn_decode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *val)
10818 {
10819 /* skip val->{sType,pNext} */
10820 vn_decode_VkBool32(dec, &val->nonSeamlessCubeMap);
10821 }
10822
10823 static inline void
vn_decode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT * val)10824 vn_decode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *val)
10825 {
10826 VkStructureType stype;
10827 vn_decode_VkStructureType(dec, &stype);
10828 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT);
10829
10830 assert(val->sType == stype);
10831 vn_decode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_pnext(dec, val->pNext);
10832 vn_decode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self(dec, val);
10833 }
10834
10835 static inline size_t
vn_sizeof_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_pnext_partial(const void * val)10836 vn_sizeof_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_pnext_partial(const void *val)
10837 {
10838 /* no known/supported struct */
10839 return vn_sizeof_simple_pointer(NULL);
10840 }
10841
10842 static inline size_t
vn_sizeof_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self_partial(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT * val)10843 vn_sizeof_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self_partial(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *val)
10844 {
10845 size_t size = 0;
10846 /* skip val->{sType,pNext} */
10847 /* skip val->nonSeamlessCubeMap */
10848 return size;
10849 }
10850
10851 static inline size_t
vn_sizeof_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_partial(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT * val)10852 vn_sizeof_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_partial(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *val)
10853 {
10854 size_t size = 0;
10855
10856 size += vn_sizeof_VkStructureType(&val->sType);
10857 size += vn_sizeof_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_pnext_partial(val->pNext);
10858 size += vn_sizeof_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self_partial(val);
10859
10860 return size;
10861 }
10862
10863 static inline void
vn_encode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)10864 vn_encode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
10865 {
10866 /* no known/supported struct */
10867 vn_encode_simple_pointer(enc, NULL);
10868 }
10869
10870 static inline void
vn_encode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT * val)10871 vn_encode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *val)
10872 {
10873 /* skip val->{sType,pNext} */
10874 /* skip val->nonSeamlessCubeMap */
10875 }
10876
10877 static inline void
vn_encode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT * val)10878 vn_encode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *val)
10879 {
10880 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT);
10881 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT });
10882 vn_encode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_pnext_partial(enc, val->pNext);
10883 vn_encode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self_partial(enc, val);
10884 }
10885
10886 /* struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT chain */
10887
10888 static inline size_t
vn_sizeof_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_pnext(const void * val)10889 vn_sizeof_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_pnext(const void *val)
10890 {
10891 /* no known/supported struct */
10892 return vn_sizeof_simple_pointer(NULL);
10893 }
10894
10895 static inline size_t
vn_sizeof_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self(const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT * val)10896 vn_sizeof_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self(const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *val)
10897 {
10898 size_t size = 0;
10899 /* skip val->{sType,pNext} */
10900 size += vn_sizeof_VkBool32(&val->attachmentFeedbackLoopLayout);
10901 return size;
10902 }
10903
10904 static inline size_t
vn_sizeof_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT * val)10905 vn_sizeof_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *val)
10906 {
10907 size_t size = 0;
10908
10909 size += vn_sizeof_VkStructureType(&val->sType);
10910 size += vn_sizeof_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_pnext(val->pNext);
10911 size += vn_sizeof_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self(val);
10912
10913 return size;
10914 }
10915
10916 static inline void
vn_encode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)10917 vn_encode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
10918 {
10919 /* no known/supported struct */
10920 vn_encode_simple_pointer(enc, NULL);
10921 }
10922
10923 static inline void
vn_encode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT * val)10924 vn_encode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *val)
10925 {
10926 /* skip val->{sType,pNext} */
10927 vn_encode_VkBool32(enc, &val->attachmentFeedbackLoopLayout);
10928 }
10929
10930 static inline void
vn_encode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT * val)10931 vn_encode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *val)
10932 {
10933 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT);
10934 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT });
10935 vn_encode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_pnext(enc, val->pNext);
10936 vn_encode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self(enc, val);
10937 }
10938
10939 static inline void
vn_decode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)10940 vn_decode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
10941 {
10942 /* no known/supported struct */
10943 if (vn_decode_simple_pointer(dec))
10944 assert(false);
10945 }
10946
10947 static inline void
vn_decode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT * val)10948 vn_decode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *val)
10949 {
10950 /* skip val->{sType,pNext} */
10951 vn_decode_VkBool32(dec, &val->attachmentFeedbackLoopLayout);
10952 }
10953
10954 static inline void
vn_decode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT * val)10955 vn_decode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *val)
10956 {
10957 VkStructureType stype;
10958 vn_decode_VkStructureType(dec, &stype);
10959 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT);
10960
10961 assert(val->sType == stype);
10962 vn_decode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_pnext(dec, val->pNext);
10963 vn_decode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self(dec, val);
10964 }
10965
10966 static inline size_t
vn_sizeof_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_pnext_partial(const void * val)10967 vn_sizeof_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_pnext_partial(const void *val)
10968 {
10969 /* no known/supported struct */
10970 return vn_sizeof_simple_pointer(NULL);
10971 }
10972
10973 static inline size_t
vn_sizeof_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self_partial(const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT * val)10974 vn_sizeof_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self_partial(const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *val)
10975 {
10976 size_t size = 0;
10977 /* skip val->{sType,pNext} */
10978 /* skip val->attachmentFeedbackLoopLayout */
10979 return size;
10980 }
10981
10982 static inline size_t
vn_sizeof_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_partial(const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT * val)10983 vn_sizeof_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_partial(const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *val)
10984 {
10985 size_t size = 0;
10986
10987 size += vn_sizeof_VkStructureType(&val->sType);
10988 size += vn_sizeof_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_pnext_partial(val->pNext);
10989 size += vn_sizeof_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self_partial(val);
10990
10991 return size;
10992 }
10993
10994 static inline void
vn_encode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)10995 vn_encode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
10996 {
10997 /* no known/supported struct */
10998 vn_encode_simple_pointer(enc, NULL);
10999 }
11000
11001 static inline void
vn_encode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT * val)11002 vn_encode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *val)
11003 {
11004 /* skip val->{sType,pNext} */
11005 /* skip val->attachmentFeedbackLoopLayout */
11006 }
11007
11008 static inline void
vn_encode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT * val)11009 vn_encode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *val)
11010 {
11011 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT);
11012 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT });
11013 vn_encode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_pnext_partial(enc, val->pNext);
11014 vn_encode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self_partial(enc, val);
11015 }
11016
11017 /* struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT chain */
11018
11019 static inline size_t
vn_sizeof_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_pnext(const void * val)11020 vn_sizeof_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_pnext(const void *val)
11021 {
11022 /* no known/supported struct */
11023 return vn_sizeof_simple_pointer(NULL);
11024 }
11025
11026 static inline size_t
vn_sizeof_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self(const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT * val)11027 vn_sizeof_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self(const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *val)
11028 {
11029 size_t size = 0;
11030 /* skip val->{sType,pNext} */
11031 size += vn_sizeof_VkBool32(&val->dynamicRenderingUnusedAttachments);
11032 return size;
11033 }
11034
11035 static inline size_t
vn_sizeof_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT * val)11036 vn_sizeof_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *val)
11037 {
11038 size_t size = 0;
11039
11040 size += vn_sizeof_VkStructureType(&val->sType);
11041 size += vn_sizeof_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_pnext(val->pNext);
11042 size += vn_sizeof_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self(val);
11043
11044 return size;
11045 }
11046
11047 static inline void
vn_encode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)11048 vn_encode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
11049 {
11050 /* no known/supported struct */
11051 vn_encode_simple_pointer(enc, NULL);
11052 }
11053
11054 static inline void
vn_encode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT * val)11055 vn_encode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *val)
11056 {
11057 /* skip val->{sType,pNext} */
11058 vn_encode_VkBool32(enc, &val->dynamicRenderingUnusedAttachments);
11059 }
11060
11061 static inline void
vn_encode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT * val)11062 vn_encode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *val)
11063 {
11064 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT);
11065 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT });
11066 vn_encode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_pnext(enc, val->pNext);
11067 vn_encode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self(enc, val);
11068 }
11069
11070 static inline void
vn_decode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)11071 vn_decode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
11072 {
11073 /* no known/supported struct */
11074 if (vn_decode_simple_pointer(dec))
11075 assert(false);
11076 }
11077
11078 static inline void
vn_decode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT * val)11079 vn_decode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *val)
11080 {
11081 /* skip val->{sType,pNext} */
11082 vn_decode_VkBool32(dec, &val->dynamicRenderingUnusedAttachments);
11083 }
11084
11085 static inline void
vn_decode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT * val)11086 vn_decode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *val)
11087 {
11088 VkStructureType stype;
11089 vn_decode_VkStructureType(dec, &stype);
11090 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT);
11091
11092 assert(val->sType == stype);
11093 vn_decode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_pnext(dec, val->pNext);
11094 vn_decode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self(dec, val);
11095 }
11096
11097 static inline size_t
vn_sizeof_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_pnext_partial(const void * val)11098 vn_sizeof_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_pnext_partial(const void *val)
11099 {
11100 /* no known/supported struct */
11101 return vn_sizeof_simple_pointer(NULL);
11102 }
11103
11104 static inline size_t
vn_sizeof_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self_partial(const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT * val)11105 vn_sizeof_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self_partial(const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *val)
11106 {
11107 size_t size = 0;
11108 /* skip val->{sType,pNext} */
11109 /* skip val->dynamicRenderingUnusedAttachments */
11110 return size;
11111 }
11112
11113 static inline size_t
vn_sizeof_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_partial(const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT * val)11114 vn_sizeof_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_partial(const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *val)
11115 {
11116 size_t size = 0;
11117
11118 size += vn_sizeof_VkStructureType(&val->sType);
11119 size += vn_sizeof_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_pnext_partial(val->pNext);
11120 size += vn_sizeof_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self_partial(val);
11121
11122 return size;
11123 }
11124
11125 static inline void
vn_encode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)11126 vn_encode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
11127 {
11128 /* no known/supported struct */
11129 vn_encode_simple_pointer(enc, NULL);
11130 }
11131
11132 static inline void
vn_encode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT * val)11133 vn_encode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *val)
11134 {
11135 /* skip val->{sType,pNext} */
11136 /* skip val->dynamicRenderingUnusedAttachments */
11137 }
11138
11139 static inline void
vn_encode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT * val)11140 vn_encode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *val)
11141 {
11142 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT);
11143 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT });
11144 vn_encode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_pnext_partial(enc, val->pNext);
11145 vn_encode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self_partial(enc, val);
11146 }
11147
11148 /* struct VkPhysicalDeviceFeatures2 chain */
11149
11150 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_pnext(const void * val)11151 vn_sizeof_VkPhysicalDeviceFeatures2_pnext(const void *val)
11152 {
11153 const VkBaseInStructure *pnext = val;
11154 size_t size = 0;
11155
11156 while (pnext) {
11157 switch ((int32_t)pnext->sType) {
11158 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
11159 if (!vn_cs_renderer_protocol_has_extension(296 /* VK_EXT_private_data */))
11160 break;
11161 size += vn_sizeof_simple_pointer(pnext);
11162 size += vn_sizeof_VkStructureType(&pnext->sType);
11163 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11164 size += vn_sizeof_VkPhysicalDevicePrivateDataFeatures_self((const VkPhysicalDevicePrivateDataFeatures *)pnext);
11165 return size;
11166 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
11167 size += vn_sizeof_simple_pointer(pnext);
11168 size += vn_sizeof_VkStructureType(&pnext->sType);
11169 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11170 size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self((const VkPhysicalDeviceVariablePointersFeatures *)pnext);
11171 return size;
11172 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
11173 size += vn_sizeof_simple_pointer(pnext);
11174 size += vn_sizeof_VkStructureType(&pnext->sType);
11175 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11176 size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self((const VkPhysicalDeviceMultiviewFeatures *)pnext);
11177 return size;
11178 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
11179 size += vn_sizeof_simple_pointer(pnext);
11180 size += vn_sizeof_VkStructureType(&pnext->sType);
11181 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11182 size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self((const VkPhysicalDevice16BitStorageFeatures *)pnext);
11183 return size;
11184 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
11185 size += vn_sizeof_simple_pointer(pnext);
11186 size += vn_sizeof_VkStructureType(&pnext->sType);
11187 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11188 size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
11189 return size;
11190 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
11191 size += vn_sizeof_simple_pointer(pnext);
11192 size += vn_sizeof_VkStructureType(&pnext->sType);
11193 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11194 size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
11195 return size;
11196 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
11197 size += vn_sizeof_simple_pointer(pnext);
11198 size += vn_sizeof_VkStructureType(&pnext->sType);
11199 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11200 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
11201 return size;
11202 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
11203 if (!vn_cs_renderer_protocol_has_extension(393 /* VK_EXT_multi_draw */))
11204 break;
11205 size += vn_sizeof_simple_pointer(pnext);
11206 size += vn_sizeof_VkStructureType(&pnext->sType);
11207 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11208 size += vn_sizeof_VkPhysicalDeviceMultiDrawFeaturesEXT_self((const VkPhysicalDeviceMultiDrawFeaturesEXT *)pnext);
11209 return size;
11210 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
11211 if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
11212 break;
11213 size += vn_sizeof_simple_pointer(pnext);
11214 size += vn_sizeof_VkStructureType(&pnext->sType);
11215 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11216 size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self((const VkPhysicalDeviceInlineUniformBlockFeatures *)pnext);
11217 return size;
11218 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
11219 if (!vn_cs_renderer_protocol_has_extension(414 /* VK_KHR_maintenance4 */))
11220 break;
11221 size += vn_sizeof_simple_pointer(pnext);
11222 size += vn_sizeof_VkStructureType(&pnext->sType);
11223 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11224 size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_self((const VkPhysicalDeviceMaintenance4Features *)pnext);
11225 return size;
11226 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
11227 if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
11228 break;
11229 size += vn_sizeof_simple_pointer(pnext);
11230 size += vn_sizeof_VkStructureType(&pnext->sType);
11231 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11232 size += vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_self((const VkPhysicalDeviceMaintenance5FeaturesKHR *)pnext);
11233 return size;
11234 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
11235 size += vn_sizeof_simple_pointer(pnext);
11236 size += vn_sizeof_VkStructureType(&pnext->sType);
11237 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11238 size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
11239 return size;
11240 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
11241 size += vn_sizeof_simple_pointer(pnext);
11242 size += vn_sizeof_VkStructureType(&pnext->sType);
11243 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11244 size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
11245 return size;
11246 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
11247 size += vn_sizeof_simple_pointer(pnext);
11248 size += vn_sizeof_VkStructureType(&pnext->sType);
11249 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11250 size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self((const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
11251 return size;
11252 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
11253 size += vn_sizeof_simple_pointer(pnext);
11254 size += vn_sizeof_VkStructureType(&pnext->sType);
11255 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11256 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
11257 return size;
11258 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
11259 size += vn_sizeof_simple_pointer(pnext);
11260 size += vn_sizeof_VkStructureType(&pnext->sType);
11261 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11262 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
11263 return size;
11264 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
11265 size += vn_sizeof_simple_pointer(pnext);
11266 size += vn_sizeof_VkStructureType(&pnext->sType);
11267 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11268 size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self((const VkPhysicalDevice8BitStorageFeatures *)pnext);
11269 return size;
11270 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
11271 if (!vn_cs_renderer_protocol_has_extension(82 /* VK_EXT_conditional_rendering */))
11272 break;
11273 size += vn_sizeof_simple_pointer(pnext);
11274 size += vn_sizeof_VkStructureType(&pnext->sType);
11275 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11276 size += vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self((const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)pnext);
11277 return size;
11278 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
11279 size += vn_sizeof_simple_pointer(pnext);
11280 size += vn_sizeof_VkStructureType(&pnext->sType);
11281 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11282 size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
11283 return size;
11284 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
11285 size += vn_sizeof_simple_pointer(pnext);
11286 size += vn_sizeof_VkStructureType(&pnext->sType);
11287 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11288 size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
11289 return size;
11290 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
11291 if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
11292 break;
11293 size += vn_sizeof_simple_pointer(pnext);
11294 size += vn_sizeof_VkStructureType(&pnext->sType);
11295 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11296 size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self((const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)pnext);
11297 return size;
11298 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
11299 if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
11300 break;
11301 size += vn_sizeof_simple_pointer(pnext);
11302 size += vn_sizeof_VkStructureType(&pnext->sType);
11303 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11304 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
11305 return size;
11306 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
11307 size += vn_sizeof_simple_pointer(pnext);
11308 size += vn_sizeof_VkStructureType(&pnext->sType);
11309 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11310 size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
11311 return size;
11312 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
11313 size += vn_sizeof_simple_pointer(pnext);
11314 size += vn_sizeof_VkStructureType(&pnext->sType);
11315 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11316 size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
11317 return size;
11318 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
11319 if (!vn_cs_renderer_protocol_has_extension(103 /* VK_EXT_depth_clip_enable */))
11320 break;
11321 size += vn_sizeof_simple_pointer(pnext);
11322 size += vn_sizeof_VkStructureType(&pnext->sType);
11323 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11324 size += vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self((const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)pnext);
11325 return size;
11326 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
11327 size += vn_sizeof_simple_pointer(pnext);
11328 size += vn_sizeof_VkStructureType(&pnext->sType);
11329 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11330 size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
11331 return size;
11332 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
11333 size += vn_sizeof_simple_pointer(pnext);
11334 size += vn_sizeof_VkStructureType(&pnext->sType);
11335 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11336 size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
11337 return size;
11338 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
11339 if (!vn_cs_renderer_protocol_has_extension(67 /* VK_EXT_texture_compression_astc_hdr */))
11340 break;
11341 size += vn_sizeof_simple_pointer(pnext);
11342 size += vn_sizeof_VkStructureType(&pnext->sType);
11343 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11344 size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self((const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext);
11345 return size;
11346 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
11347 if (!vn_cs_renderer_protocol_has_extension(182 /* VK_KHR_shader_clock */))
11348 break;
11349 size += vn_sizeof_simple_pointer(pnext);
11350 size += vn_sizeof_VkStructureType(&pnext->sType);
11351 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11352 size += vn_sizeof_VkPhysicalDeviceShaderClockFeaturesKHR_self((const VkPhysicalDeviceShaderClockFeaturesKHR *)pnext);
11353 return size;
11354 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
11355 if (!vn_cs_renderer_protocol_has_extension(266 /* VK_EXT_index_type_uint8 */))
11356 break;
11357 size += vn_sizeof_simple_pointer(pnext);
11358 size += vn_sizeof_VkStructureType(&pnext->sType);
11359 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11360 size += vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self((const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)pnext);
11361 return size;
11362 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
11363 if (!vn_cs_renderer_protocol_has_extension(252 /* VK_EXT_fragment_shader_interlock */))
11364 break;
11365 size += vn_sizeof_simple_pointer(pnext);
11366 size += vn_sizeof_VkStructureType(&pnext->sType);
11367 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11368 size += vn_sizeof_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self((const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)pnext);
11369 return size;
11370 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
11371 size += vn_sizeof_simple_pointer(pnext);
11372 size += vn_sizeof_VkStructureType(&pnext->sType);
11373 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11374 size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
11375 return size;
11376 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
11377 if (!vn_cs_renderer_protocol_has_extension(357 /* VK_EXT_primitive_topology_list_restart */))
11378 break;
11379 size += vn_sizeof_simple_pointer(pnext);
11380 size += vn_sizeof_VkStructureType(&pnext->sType);
11381 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11382 size += vn_sizeof_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self((const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)pnext);
11383 return size;
11384 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
11385 if (!vn_cs_renderer_protocol_has_extension(277 /* VK_EXT_shader_demote_to_helper_invocation */))
11386 break;
11387 size += vn_sizeof_simple_pointer(pnext);
11388 size += vn_sizeof_VkStructureType(&pnext->sType);
11389 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11390 size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self((const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext);
11391 return size;
11392 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
11393 if (!vn_cs_renderer_protocol_has_extension(282 /* VK_EXT_texel_buffer_alignment */))
11394 break;
11395 size += vn_sizeof_simple_pointer(pnext);
11396 size += vn_sizeof_VkStructureType(&pnext->sType);
11397 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11398 size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self((const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext);
11399 return size;
11400 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
11401 if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
11402 break;
11403 size += vn_sizeof_simple_pointer(pnext);
11404 size += vn_sizeof_VkStructureType(&pnext->sType);
11405 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11406 size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self((const VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext);
11407 return size;
11408 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
11409 if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
11410 break;
11411 size += vn_sizeof_simple_pointer(pnext);
11412 size += vn_sizeof_VkStructureType(&pnext->sType);
11413 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11414 size += vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_self((const VkPhysicalDeviceLineRasterizationFeaturesEXT *)pnext);
11415 return size;
11416 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
11417 if (!vn_cs_renderer_protocol_has_extension(298 /* VK_EXT_pipeline_creation_cache_control */))
11418 break;
11419 size += vn_sizeof_simple_pointer(pnext);
11420 size += vn_sizeof_VkStructureType(&pnext->sType);
11421 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11422 size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self((const VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext);
11423 return size;
11424 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
11425 size += vn_sizeof_simple_pointer(pnext);
11426 size += vn_sizeof_VkStructureType(&pnext->sType);
11427 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11428 size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self((const VkPhysicalDeviceVulkan11Features *)pnext);
11429 return size;
11430 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
11431 size += vn_sizeof_simple_pointer(pnext);
11432 size += vn_sizeof_VkStructureType(&pnext->sType);
11433 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11434 size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self((const VkPhysicalDeviceVulkan12Features *)pnext);
11435 return size;
11436 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
11437 if (!vn_cs_renderer_protocol_has_api_version(VK_API_VERSION_1_3))
11438 break;
11439 size += vn_sizeof_simple_pointer(pnext);
11440 size += vn_sizeof_VkStructureType(&pnext->sType);
11441 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11442 size += vn_sizeof_VkPhysicalDeviceVulkan13Features_self((const VkPhysicalDeviceVulkan13Features *)pnext);
11443 return size;
11444 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
11445 if (!vn_cs_renderer_protocol_has_extension(288 /* VK_EXT_custom_border_color */))
11446 break;
11447 size += vn_sizeof_simple_pointer(pnext);
11448 size += vn_sizeof_VkStructureType(&pnext->sType);
11449 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11450 size += vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self((const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)pnext);
11451 return size;
11452 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
11453 if (!vn_cs_renderer_protocol_has_extension(412 /* VK_EXT_border_color_swizzle */))
11454 break;
11455 size += vn_sizeof_simple_pointer(pnext);
11456 size += vn_sizeof_VkStructureType(&pnext->sType);
11457 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11458 size += vn_sizeof_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self((const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)pnext);
11459 return size;
11460 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
11461 if (!vn_cs_renderer_protocol_has_extension(268 /* VK_EXT_extended_dynamic_state */))
11462 break;
11463 size += vn_sizeof_simple_pointer(pnext);
11464 size += vn_sizeof_VkStructureType(&pnext->sType);
11465 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11466 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self((const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext);
11467 return size;
11468 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
11469 if (!vn_cs_renderer_protocol_has_extension(378 /* VK_EXT_extended_dynamic_state2 */))
11470 break;
11471 size += vn_sizeof_simple_pointer(pnext);
11472 size += vn_sizeof_VkStructureType(&pnext->sType);
11473 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11474 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self((const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext);
11475 return size;
11476 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
11477 if (!vn_cs_renderer_protocol_has_extension(456 /* VK_EXT_extended_dynamic_state3 */))
11478 break;
11479 size += vn_sizeof_simple_pointer(pnext);
11480 size += vn_sizeof_VkStructureType(&pnext->sType);
11481 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11482 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self((const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)pnext);
11483 return size;
11484 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
11485 if (!vn_cs_renderer_protocol_has_extension(326 /* VK_KHR_zero_initialize_workgroup_memory */))
11486 break;
11487 size += vn_sizeof_simple_pointer(pnext);
11488 size += vn_sizeof_VkStructureType(&pnext->sType);
11489 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11490 size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self((const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext);
11491 return size;
11492 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
11493 if (!vn_cs_renderer_protocol_has_extension(287 /* VK_EXT_robustness2 */))
11494 break;
11495 size += vn_sizeof_simple_pointer(pnext);
11496 size += vn_sizeof_VkStructureType(&pnext->sType);
11497 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11498 size += vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_self((const VkPhysicalDeviceRobustness2FeaturesEXT *)pnext);
11499 return size;
11500 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
11501 if (!vn_cs_renderer_protocol_has_extension(336 /* VK_EXT_image_robustness */))
11502 break;
11503 size += vn_sizeof_simple_pointer(pnext);
11504 size += vn_sizeof_VkStructureType(&pnext->sType);
11505 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11506 size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self((const VkPhysicalDeviceImageRobustnessFeatures *)pnext);
11507 return size;
11508 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
11509 if (!vn_cs_renderer_protocol_has_extension(341 /* VK_EXT_4444_formats */))
11510 break;
11511 size += vn_sizeof_simple_pointer(pnext);
11512 size += vn_sizeof_VkStructureType(&pnext->sType);
11513 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11514 size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self((const VkPhysicalDevice4444FormatsFeaturesEXT *)pnext);
11515 return size;
11516 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
11517 if (!vn_cs_renderer_protocol_has_extension(227 /* VK_KHR_fragment_shading_rate */))
11518 break;
11519 size += vn_sizeof_simple_pointer(pnext);
11520 size += vn_sizeof_VkStructureType(&pnext->sType);
11521 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11522 size += vn_sizeof_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self((const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)pnext);
11523 return size;
11524 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
11525 if (!vn_cs_renderer_protocol_has_extension(216 /* VK_KHR_shader_terminate_invocation */))
11526 break;
11527 size += vn_sizeof_simple_pointer(pnext);
11528 size += vn_sizeof_VkStructureType(&pnext->sType);
11529 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11530 size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self((const VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext);
11531 return size;
11532 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
11533 if (!vn_cs_renderer_protocol_has_extension(394 /* VK_EXT_image_2d_view_of_3d */))
11534 break;
11535 size += vn_sizeof_simple_pointer(pnext);
11536 size += vn_sizeof_VkStructureType(&pnext->sType);
11537 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11538 size += vn_sizeof_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self((const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)pnext);
11539 return size;
11540 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
11541 if (!vn_cs_renderer_protocol_has_extension(352 /* VK_VALVE_mutable_descriptor_type */) && !vn_cs_renderer_protocol_has_extension(495 /* VK_EXT_mutable_descriptor_type */))
11542 break;
11543 size += vn_sizeof_simple_pointer(pnext);
11544 size += vn_sizeof_VkStructureType(&pnext->sType);
11545 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11546 size += vn_sizeof_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self((const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)pnext);
11547 return size;
11548 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
11549 if (!vn_cs_renderer_protocol_has_extension(356 /* VK_EXT_depth_clip_control */))
11550 break;
11551 size += vn_sizeof_simple_pointer(pnext);
11552 size += vn_sizeof_VkStructureType(&pnext->sType);
11553 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11554 size += vn_sizeof_VkPhysicalDeviceDepthClipControlFeaturesEXT_self((const VkPhysicalDeviceDepthClipControlFeaturesEXT *)pnext);
11555 return size;
11556 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
11557 if (!vn_cs_renderer_protocol_has_extension(353 /* VK_EXT_vertex_input_dynamic_state */))
11558 break;
11559 size += vn_sizeof_simple_pointer(pnext);
11560 size += vn_sizeof_VkStructureType(&pnext->sType);
11561 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11562 size += vn_sizeof_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self((const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)pnext);
11563 return size;
11564 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
11565 if (!vn_cs_renderer_protocol_has_extension(382 /* VK_EXT_color_write_enable */))
11566 break;
11567 size += vn_sizeof_simple_pointer(pnext);
11568 size += vn_sizeof_VkStructureType(&pnext->sType);
11569 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11570 size += vn_sizeof_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self((const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)pnext);
11571 return size;
11572 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
11573 if (!vn_cs_renderer_protocol_has_extension(315 /* VK_KHR_synchronization2 */))
11574 break;
11575 size += vn_sizeof_simple_pointer(pnext);
11576 size += vn_sizeof_VkStructureType(&pnext->sType);
11577 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11578 size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_self((const VkPhysicalDeviceSynchronization2Features *)pnext);
11579 return size;
11580 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
11581 if (!vn_cs_renderer_protocol_has_extension(383 /* VK_EXT_primitives_generated_query */))
11582 break;
11583 size += vn_sizeof_simple_pointer(pnext);
11584 size += vn_sizeof_VkStructureType(&pnext->sType);
11585 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11586 size += vn_sizeof_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self((const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)pnext);
11587 return size;
11588 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
11589 if (!vn_cs_renderer_protocol_has_extension(331 /* VK_EXT_ycbcr_2plane_444_formats */))
11590 break;
11591 size += vn_sizeof_simple_pointer(pnext);
11592 size += vn_sizeof_VkStructureType(&pnext->sType);
11593 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11594 size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self((const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext);
11595 return size;
11596 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
11597 if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
11598 break;
11599 size += vn_sizeof_simple_pointer(pnext);
11600 size += vn_sizeof_VkStructureType(&pnext->sType);
11601 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11602 size += vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_self((const VkPhysicalDeviceProvokingVertexFeaturesEXT *)pnext);
11603 return size;
11604 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
11605 if (!vn_cs_renderer_protocol_has_extension(281 /* VK_KHR_shader_integer_dot_product */))
11606 break;
11607 size += vn_sizeof_simple_pointer(pnext);
11608 size += vn_sizeof_VkStructureType(&pnext->sType);
11609 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11610 size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self((const VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext);
11611 return size;
11612 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
11613 if (!vn_cs_renderer_protocol_has_extension(45 /* VK_KHR_dynamic_rendering */))
11614 break;
11615 size += vn_sizeof_simple_pointer(pnext);
11616 size += vn_sizeof_VkStructureType(&pnext->sType);
11617 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11618 size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self((const VkPhysicalDeviceDynamicRenderingFeatures *)pnext);
11619 return size;
11620 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
11621 if (!vn_cs_renderer_protocol_has_extension(392 /* VK_EXT_image_view_min_lod */))
11622 break;
11623 size += vn_sizeof_simple_pointer(pnext);
11624 size += vn_sizeof_VkStructureType(&pnext->sType);
11625 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11626 size += vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self((const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)pnext);
11627 return size;
11628 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
11629 if (!vn_cs_renderer_protocol_has_extension(464 /* VK_EXT_rasterization_order_attachment_access */))
11630 break;
11631 size += vn_sizeof_simple_pointer(pnext);
11632 size += vn_sizeof_VkStructureType(&pnext->sType);
11633 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11634 size += vn_sizeof_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self((const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)pnext);
11635 return size;
11636 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
11637 if (!vn_cs_renderer_protocol_has_extension(321 /* VK_EXT_graphics_pipeline_library */))
11638 break;
11639 size += vn_sizeof_simple_pointer(pnext);
11640 size += vn_sizeof_VkStructureType(&pnext->sType);
11641 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11642 size += vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self((const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)pnext);
11643 return size;
11644 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
11645 if (!vn_cs_renderer_protocol_has_extension(423 /* VK_EXT_non_seamless_cube_map */))
11646 break;
11647 size += vn_sizeof_simple_pointer(pnext);
11648 size += vn_sizeof_VkStructureType(&pnext->sType);
11649 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11650 size += vn_sizeof_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self((const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)pnext);
11651 return size;
11652 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
11653 if (!vn_cs_renderer_protocol_has_extension(340 /* VK_EXT_attachment_feedback_loop_layout */))
11654 break;
11655 size += vn_sizeof_simple_pointer(pnext);
11656 size += vn_sizeof_VkStructureType(&pnext->sType);
11657 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11658 size += vn_sizeof_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self((const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)pnext);
11659 return size;
11660 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
11661 if (!vn_cs_renderer_protocol_has_extension(500 /* VK_EXT_dynamic_rendering_unused_attachments */))
11662 break;
11663 size += vn_sizeof_simple_pointer(pnext);
11664 size += vn_sizeof_VkStructureType(&pnext->sType);
11665 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
11666 size += vn_sizeof_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self((const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)pnext);
11667 return size;
11668 default:
11669 /* ignore unknown/unsupported struct */
11670 break;
11671 }
11672 pnext = pnext->pNext;
11673 }
11674
11675 return vn_sizeof_simple_pointer(NULL);
11676 }
11677
11678 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_self(const VkPhysicalDeviceFeatures2 * val)11679 vn_sizeof_VkPhysicalDeviceFeatures2_self(const VkPhysicalDeviceFeatures2 *val)
11680 {
11681 size_t size = 0;
11682 /* skip val->{sType,pNext} */
11683 size += vn_sizeof_VkPhysicalDeviceFeatures(&val->features);
11684 return size;
11685 }
11686
11687 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2 * val)11688 vn_sizeof_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2 *val)
11689 {
11690 size_t size = 0;
11691
11692 size += vn_sizeof_VkStructureType(&val->sType);
11693 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(val->pNext);
11694 size += vn_sizeof_VkPhysicalDeviceFeatures2_self(val);
11695
11696 return size;
11697 }
11698
11699 static inline void
vn_encode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_encoder * enc,const void * val)11700 vn_encode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_encoder *enc, const void *val)
11701 {
11702 const VkBaseInStructure *pnext = val;
11703
11704 while (pnext) {
11705 switch ((int32_t)pnext->sType) {
11706 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
11707 if (!vn_cs_renderer_protocol_has_extension(296 /* VK_EXT_private_data */))
11708 break;
11709 vn_encode_simple_pointer(enc, pnext);
11710 vn_encode_VkStructureType(enc, &pnext->sType);
11711 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11712 vn_encode_VkPhysicalDevicePrivateDataFeatures_self(enc, (const VkPhysicalDevicePrivateDataFeatures *)pnext);
11713 return;
11714 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
11715 vn_encode_simple_pointer(enc, pnext);
11716 vn_encode_VkStructureType(enc, &pnext->sType);
11717 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11718 vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext);
11719 return;
11720 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
11721 vn_encode_simple_pointer(enc, pnext);
11722 vn_encode_VkStructureType(enc, &pnext->sType);
11723 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11724 vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext);
11725 return;
11726 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
11727 vn_encode_simple_pointer(enc, pnext);
11728 vn_encode_VkStructureType(enc, &pnext->sType);
11729 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11730 vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext);
11731 return;
11732 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
11733 vn_encode_simple_pointer(enc, pnext);
11734 vn_encode_VkStructureType(enc, &pnext->sType);
11735 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11736 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
11737 return;
11738 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
11739 vn_encode_simple_pointer(enc, pnext);
11740 vn_encode_VkStructureType(enc, &pnext->sType);
11741 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11742 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
11743 return;
11744 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
11745 vn_encode_simple_pointer(enc, pnext);
11746 vn_encode_VkStructureType(enc, &pnext->sType);
11747 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11748 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
11749 return;
11750 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
11751 if (!vn_cs_renderer_protocol_has_extension(393 /* VK_EXT_multi_draw */))
11752 break;
11753 vn_encode_simple_pointer(enc, pnext);
11754 vn_encode_VkStructureType(enc, &pnext->sType);
11755 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11756 vn_encode_VkPhysicalDeviceMultiDrawFeaturesEXT_self(enc, (const VkPhysicalDeviceMultiDrawFeaturesEXT *)pnext);
11757 return;
11758 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
11759 if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
11760 break;
11761 vn_encode_simple_pointer(enc, pnext);
11762 vn_encode_VkStructureType(enc, &pnext->sType);
11763 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11764 vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self(enc, (const VkPhysicalDeviceInlineUniformBlockFeatures *)pnext);
11765 return;
11766 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
11767 if (!vn_cs_renderer_protocol_has_extension(414 /* VK_KHR_maintenance4 */))
11768 break;
11769 vn_encode_simple_pointer(enc, pnext);
11770 vn_encode_VkStructureType(enc, &pnext->sType);
11771 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11772 vn_encode_VkPhysicalDeviceMaintenance4Features_self(enc, (const VkPhysicalDeviceMaintenance4Features *)pnext);
11773 return;
11774 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
11775 if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
11776 break;
11777 vn_encode_simple_pointer(enc, pnext);
11778 vn_encode_VkStructureType(enc, &pnext->sType);
11779 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11780 vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_self(enc, (const VkPhysicalDeviceMaintenance5FeaturesKHR *)pnext);
11781 return;
11782 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
11783 vn_encode_simple_pointer(enc, pnext);
11784 vn_encode_VkStructureType(enc, &pnext->sType);
11785 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11786 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
11787 return;
11788 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
11789 vn_encode_simple_pointer(enc, pnext);
11790 vn_encode_VkStructureType(enc, &pnext->sType);
11791 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11792 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
11793 return;
11794 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
11795 vn_encode_simple_pointer(enc, pnext);
11796 vn_encode_VkStructureType(enc, &pnext->sType);
11797 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11798 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
11799 return;
11800 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
11801 vn_encode_simple_pointer(enc, pnext);
11802 vn_encode_VkStructureType(enc, &pnext->sType);
11803 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11804 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
11805 return;
11806 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
11807 vn_encode_simple_pointer(enc, pnext);
11808 vn_encode_VkStructureType(enc, &pnext->sType);
11809 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11810 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
11811 return;
11812 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
11813 vn_encode_simple_pointer(enc, pnext);
11814 vn_encode_VkStructureType(enc, &pnext->sType);
11815 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11816 vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext);
11817 return;
11818 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
11819 if (!vn_cs_renderer_protocol_has_extension(82 /* VK_EXT_conditional_rendering */))
11820 break;
11821 vn_encode_simple_pointer(enc, pnext);
11822 vn_encode_VkStructureType(enc, &pnext->sType);
11823 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11824 vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(enc, (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)pnext);
11825 return;
11826 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
11827 vn_encode_simple_pointer(enc, pnext);
11828 vn_encode_VkStructureType(enc, &pnext->sType);
11829 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11830 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
11831 return;
11832 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
11833 vn_encode_simple_pointer(enc, pnext);
11834 vn_encode_VkStructureType(enc, &pnext->sType);
11835 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11836 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
11837 return;
11838 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
11839 if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
11840 break;
11841 vn_encode_simple_pointer(enc, pnext);
11842 vn_encode_VkStructureType(enc, &pnext->sType);
11843 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11844 vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(enc, (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)pnext);
11845 return;
11846 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
11847 if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
11848 break;
11849 vn_encode_simple_pointer(enc, pnext);
11850 vn_encode_VkStructureType(enc, &pnext->sType);
11851 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11852 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
11853 return;
11854 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
11855 vn_encode_simple_pointer(enc, pnext);
11856 vn_encode_VkStructureType(enc, &pnext->sType);
11857 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11858 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
11859 return;
11860 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
11861 vn_encode_simple_pointer(enc, pnext);
11862 vn_encode_VkStructureType(enc, &pnext->sType);
11863 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11864 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
11865 return;
11866 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
11867 if (!vn_cs_renderer_protocol_has_extension(103 /* VK_EXT_depth_clip_enable */))
11868 break;
11869 vn_encode_simple_pointer(enc, pnext);
11870 vn_encode_VkStructureType(enc, &pnext->sType);
11871 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11872 vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(enc, (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)pnext);
11873 return;
11874 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
11875 vn_encode_simple_pointer(enc, pnext);
11876 vn_encode_VkStructureType(enc, &pnext->sType);
11877 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11878 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
11879 return;
11880 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
11881 vn_encode_simple_pointer(enc, pnext);
11882 vn_encode_VkStructureType(enc, &pnext->sType);
11883 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11884 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
11885 return;
11886 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
11887 if (!vn_cs_renderer_protocol_has_extension(67 /* VK_EXT_texture_compression_astc_hdr */))
11888 break;
11889 vn_encode_simple_pointer(enc, pnext);
11890 vn_encode_VkStructureType(enc, &pnext->sType);
11891 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11892 vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(enc, (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext);
11893 return;
11894 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
11895 if (!vn_cs_renderer_protocol_has_extension(182 /* VK_KHR_shader_clock */))
11896 break;
11897 vn_encode_simple_pointer(enc, pnext);
11898 vn_encode_VkStructureType(enc, &pnext->sType);
11899 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11900 vn_encode_VkPhysicalDeviceShaderClockFeaturesKHR_self(enc, (const VkPhysicalDeviceShaderClockFeaturesKHR *)pnext);
11901 return;
11902 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
11903 if (!vn_cs_renderer_protocol_has_extension(266 /* VK_EXT_index_type_uint8 */))
11904 break;
11905 vn_encode_simple_pointer(enc, pnext);
11906 vn_encode_VkStructureType(enc, &pnext->sType);
11907 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11908 vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(enc, (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)pnext);
11909 return;
11910 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
11911 if (!vn_cs_renderer_protocol_has_extension(252 /* VK_EXT_fragment_shader_interlock */))
11912 break;
11913 vn_encode_simple_pointer(enc, pnext);
11914 vn_encode_VkStructureType(enc, &pnext->sType);
11915 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11916 vn_encode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self(enc, (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)pnext);
11917 return;
11918 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
11919 vn_encode_simple_pointer(enc, pnext);
11920 vn_encode_VkStructureType(enc, &pnext->sType);
11921 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11922 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
11923 return;
11924 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
11925 if (!vn_cs_renderer_protocol_has_extension(357 /* VK_EXT_primitive_topology_list_restart */))
11926 break;
11927 vn_encode_simple_pointer(enc, pnext);
11928 vn_encode_VkStructureType(enc, &pnext->sType);
11929 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11930 vn_encode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self(enc, (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)pnext);
11931 return;
11932 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
11933 if (!vn_cs_renderer_protocol_has_extension(277 /* VK_EXT_shader_demote_to_helper_invocation */))
11934 break;
11935 vn_encode_simple_pointer(enc, pnext);
11936 vn_encode_VkStructureType(enc, &pnext->sType);
11937 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11938 vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(enc, (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext);
11939 return;
11940 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
11941 if (!vn_cs_renderer_protocol_has_extension(282 /* VK_EXT_texel_buffer_alignment */))
11942 break;
11943 vn_encode_simple_pointer(enc, pnext);
11944 vn_encode_VkStructureType(enc, &pnext->sType);
11945 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11946 vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(enc, (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext);
11947 return;
11948 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
11949 if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
11950 break;
11951 vn_encode_simple_pointer(enc, pnext);
11952 vn_encode_VkStructureType(enc, &pnext->sType);
11953 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11954 vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(enc, (const VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext);
11955 return;
11956 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
11957 if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
11958 break;
11959 vn_encode_simple_pointer(enc, pnext);
11960 vn_encode_VkStructureType(enc, &pnext->sType);
11961 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11962 vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(enc, (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)pnext);
11963 return;
11964 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
11965 if (!vn_cs_renderer_protocol_has_extension(298 /* VK_EXT_pipeline_creation_cache_control */))
11966 break;
11967 vn_encode_simple_pointer(enc, pnext);
11968 vn_encode_VkStructureType(enc, &pnext->sType);
11969 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11970 vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(enc, (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext);
11971 return;
11972 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
11973 vn_encode_simple_pointer(enc, pnext);
11974 vn_encode_VkStructureType(enc, &pnext->sType);
11975 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11976 vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, (const VkPhysicalDeviceVulkan11Features *)pnext);
11977 return;
11978 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
11979 vn_encode_simple_pointer(enc, pnext);
11980 vn_encode_VkStructureType(enc, &pnext->sType);
11981 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11982 vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, (const VkPhysicalDeviceVulkan12Features *)pnext);
11983 return;
11984 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
11985 if (!vn_cs_renderer_protocol_has_api_version(VK_API_VERSION_1_3))
11986 break;
11987 vn_encode_simple_pointer(enc, pnext);
11988 vn_encode_VkStructureType(enc, &pnext->sType);
11989 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11990 vn_encode_VkPhysicalDeviceVulkan13Features_self(enc, (const VkPhysicalDeviceVulkan13Features *)pnext);
11991 return;
11992 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
11993 if (!vn_cs_renderer_protocol_has_extension(288 /* VK_EXT_custom_border_color */))
11994 break;
11995 vn_encode_simple_pointer(enc, pnext);
11996 vn_encode_VkStructureType(enc, &pnext->sType);
11997 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
11998 vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(enc, (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)pnext);
11999 return;
12000 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
12001 if (!vn_cs_renderer_protocol_has_extension(412 /* VK_EXT_border_color_swizzle */))
12002 break;
12003 vn_encode_simple_pointer(enc, pnext);
12004 vn_encode_VkStructureType(enc, &pnext->sType);
12005 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12006 vn_encode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self(enc, (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)pnext);
12007 return;
12008 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
12009 if (!vn_cs_renderer_protocol_has_extension(268 /* VK_EXT_extended_dynamic_state */))
12010 break;
12011 vn_encode_simple_pointer(enc, pnext);
12012 vn_encode_VkStructureType(enc, &pnext->sType);
12013 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12014 vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(enc, (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext);
12015 return;
12016 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
12017 if (!vn_cs_renderer_protocol_has_extension(378 /* VK_EXT_extended_dynamic_state2 */))
12018 break;
12019 vn_encode_simple_pointer(enc, pnext);
12020 vn_encode_VkStructureType(enc, &pnext->sType);
12021 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12022 vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(enc, (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext);
12023 return;
12024 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
12025 if (!vn_cs_renderer_protocol_has_extension(456 /* VK_EXT_extended_dynamic_state3 */))
12026 break;
12027 vn_encode_simple_pointer(enc, pnext);
12028 vn_encode_VkStructureType(enc, &pnext->sType);
12029 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12030 vn_encode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self(enc, (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)pnext);
12031 return;
12032 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
12033 if (!vn_cs_renderer_protocol_has_extension(326 /* VK_KHR_zero_initialize_workgroup_memory */))
12034 break;
12035 vn_encode_simple_pointer(enc, pnext);
12036 vn_encode_VkStructureType(enc, &pnext->sType);
12037 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12038 vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(enc, (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext);
12039 return;
12040 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
12041 if (!vn_cs_renderer_protocol_has_extension(287 /* VK_EXT_robustness2 */))
12042 break;
12043 vn_encode_simple_pointer(enc, pnext);
12044 vn_encode_VkStructureType(enc, &pnext->sType);
12045 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12046 vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_self(enc, (const VkPhysicalDeviceRobustness2FeaturesEXT *)pnext);
12047 return;
12048 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
12049 if (!vn_cs_renderer_protocol_has_extension(336 /* VK_EXT_image_robustness */))
12050 break;
12051 vn_encode_simple_pointer(enc, pnext);
12052 vn_encode_VkStructureType(enc, &pnext->sType);
12053 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12054 vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self(enc, (const VkPhysicalDeviceImageRobustnessFeatures *)pnext);
12055 return;
12056 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
12057 if (!vn_cs_renderer_protocol_has_extension(341 /* VK_EXT_4444_formats */))
12058 break;
12059 vn_encode_simple_pointer(enc, pnext);
12060 vn_encode_VkStructureType(enc, &pnext->sType);
12061 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12062 vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self(enc, (const VkPhysicalDevice4444FormatsFeaturesEXT *)pnext);
12063 return;
12064 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
12065 if (!vn_cs_renderer_protocol_has_extension(227 /* VK_KHR_fragment_shading_rate */))
12066 break;
12067 vn_encode_simple_pointer(enc, pnext);
12068 vn_encode_VkStructureType(enc, &pnext->sType);
12069 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12070 vn_encode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self(enc, (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)pnext);
12071 return;
12072 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
12073 if (!vn_cs_renderer_protocol_has_extension(216 /* VK_KHR_shader_terminate_invocation */))
12074 break;
12075 vn_encode_simple_pointer(enc, pnext);
12076 vn_encode_VkStructureType(enc, &pnext->sType);
12077 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12078 vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(enc, (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext);
12079 return;
12080 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
12081 if (!vn_cs_renderer_protocol_has_extension(394 /* VK_EXT_image_2d_view_of_3d */))
12082 break;
12083 vn_encode_simple_pointer(enc, pnext);
12084 vn_encode_VkStructureType(enc, &pnext->sType);
12085 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12086 vn_encode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self(enc, (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)pnext);
12087 return;
12088 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
12089 if (!vn_cs_renderer_protocol_has_extension(352 /* VK_VALVE_mutable_descriptor_type */) && !vn_cs_renderer_protocol_has_extension(495 /* VK_EXT_mutable_descriptor_type */))
12090 break;
12091 vn_encode_simple_pointer(enc, pnext);
12092 vn_encode_VkStructureType(enc, &pnext->sType);
12093 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12094 vn_encode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self(enc, (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)pnext);
12095 return;
12096 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
12097 if (!vn_cs_renderer_protocol_has_extension(356 /* VK_EXT_depth_clip_control */))
12098 break;
12099 vn_encode_simple_pointer(enc, pnext);
12100 vn_encode_VkStructureType(enc, &pnext->sType);
12101 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12102 vn_encode_VkPhysicalDeviceDepthClipControlFeaturesEXT_self(enc, (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)pnext);
12103 return;
12104 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
12105 if (!vn_cs_renderer_protocol_has_extension(353 /* VK_EXT_vertex_input_dynamic_state */))
12106 break;
12107 vn_encode_simple_pointer(enc, pnext);
12108 vn_encode_VkStructureType(enc, &pnext->sType);
12109 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12110 vn_encode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self(enc, (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)pnext);
12111 return;
12112 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
12113 if (!vn_cs_renderer_protocol_has_extension(382 /* VK_EXT_color_write_enable */))
12114 break;
12115 vn_encode_simple_pointer(enc, pnext);
12116 vn_encode_VkStructureType(enc, &pnext->sType);
12117 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12118 vn_encode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self(enc, (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)pnext);
12119 return;
12120 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
12121 if (!vn_cs_renderer_protocol_has_extension(315 /* VK_KHR_synchronization2 */))
12122 break;
12123 vn_encode_simple_pointer(enc, pnext);
12124 vn_encode_VkStructureType(enc, &pnext->sType);
12125 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12126 vn_encode_VkPhysicalDeviceSynchronization2Features_self(enc, (const VkPhysicalDeviceSynchronization2Features *)pnext);
12127 return;
12128 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
12129 if (!vn_cs_renderer_protocol_has_extension(383 /* VK_EXT_primitives_generated_query */))
12130 break;
12131 vn_encode_simple_pointer(enc, pnext);
12132 vn_encode_VkStructureType(enc, &pnext->sType);
12133 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12134 vn_encode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self(enc, (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)pnext);
12135 return;
12136 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
12137 if (!vn_cs_renderer_protocol_has_extension(331 /* VK_EXT_ycbcr_2plane_444_formats */))
12138 break;
12139 vn_encode_simple_pointer(enc, pnext);
12140 vn_encode_VkStructureType(enc, &pnext->sType);
12141 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12142 vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(enc, (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext);
12143 return;
12144 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
12145 if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
12146 break;
12147 vn_encode_simple_pointer(enc, pnext);
12148 vn_encode_VkStructureType(enc, &pnext->sType);
12149 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12150 vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(enc, (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)pnext);
12151 return;
12152 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
12153 if (!vn_cs_renderer_protocol_has_extension(281 /* VK_KHR_shader_integer_dot_product */))
12154 break;
12155 vn_encode_simple_pointer(enc, pnext);
12156 vn_encode_VkStructureType(enc, &pnext->sType);
12157 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12158 vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(enc, (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext);
12159 return;
12160 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
12161 if (!vn_cs_renderer_protocol_has_extension(45 /* VK_KHR_dynamic_rendering */))
12162 break;
12163 vn_encode_simple_pointer(enc, pnext);
12164 vn_encode_VkStructureType(enc, &pnext->sType);
12165 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12166 vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self(enc, (const VkPhysicalDeviceDynamicRenderingFeatures *)pnext);
12167 return;
12168 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
12169 if (!vn_cs_renderer_protocol_has_extension(392 /* VK_EXT_image_view_min_lod */))
12170 break;
12171 vn_encode_simple_pointer(enc, pnext);
12172 vn_encode_VkStructureType(enc, &pnext->sType);
12173 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12174 vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(enc, (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)pnext);
12175 return;
12176 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
12177 if (!vn_cs_renderer_protocol_has_extension(464 /* VK_EXT_rasterization_order_attachment_access */))
12178 break;
12179 vn_encode_simple_pointer(enc, pnext);
12180 vn_encode_VkStructureType(enc, &pnext->sType);
12181 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12182 vn_encode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self(enc, (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)pnext);
12183 return;
12184 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
12185 if (!vn_cs_renderer_protocol_has_extension(321 /* VK_EXT_graphics_pipeline_library */))
12186 break;
12187 vn_encode_simple_pointer(enc, pnext);
12188 vn_encode_VkStructureType(enc, &pnext->sType);
12189 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12190 vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self(enc, (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)pnext);
12191 return;
12192 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
12193 if (!vn_cs_renderer_protocol_has_extension(423 /* VK_EXT_non_seamless_cube_map */))
12194 break;
12195 vn_encode_simple_pointer(enc, pnext);
12196 vn_encode_VkStructureType(enc, &pnext->sType);
12197 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12198 vn_encode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self(enc, (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)pnext);
12199 return;
12200 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
12201 if (!vn_cs_renderer_protocol_has_extension(340 /* VK_EXT_attachment_feedback_loop_layout */))
12202 break;
12203 vn_encode_simple_pointer(enc, pnext);
12204 vn_encode_VkStructureType(enc, &pnext->sType);
12205 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12206 vn_encode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self(enc, (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)pnext);
12207 return;
12208 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
12209 if (!vn_cs_renderer_protocol_has_extension(500 /* VK_EXT_dynamic_rendering_unused_attachments */))
12210 break;
12211 vn_encode_simple_pointer(enc, pnext);
12212 vn_encode_VkStructureType(enc, &pnext->sType);
12213 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
12214 vn_encode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self(enc, (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)pnext);
12215 return;
12216 default:
12217 /* ignore unknown/unsupported struct */
12218 break;
12219 }
12220 pnext = pnext->pNext;
12221 }
12222
12223 vn_encode_simple_pointer(enc, NULL);
12224 }
12225
12226 static inline void
vn_encode_VkPhysicalDeviceFeatures2_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures2 * val)12227 vn_encode_VkPhysicalDeviceFeatures2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
12228 {
12229 /* skip val->{sType,pNext} */
12230 vn_encode_VkPhysicalDeviceFeatures(enc, &val->features);
12231 }
12232
12233 static inline void
vn_encode_VkPhysicalDeviceFeatures2(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures2 * val)12234 vn_encode_VkPhysicalDeviceFeatures2(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
12235 {
12236 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
12237 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 });
12238 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, val->pNext);
12239 vn_encode_VkPhysicalDeviceFeatures2_self(enc, val);
12240 }
12241
12242 static inline void
vn_decode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_decoder * dec,const void * val)12243 vn_decode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_decoder *dec, const void *val)
12244 {
12245 VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
12246 VkStructureType stype;
12247
12248 if (!vn_decode_simple_pointer(dec))
12249 return;
12250
12251 vn_decode_VkStructureType(dec, &stype);
12252 while (true) {
12253 assert(pnext);
12254 if (pnext->sType == stype)
12255 break;
12256
12257 pnext = pnext->pNext;
12258 }
12259
12260 switch ((int32_t)pnext->sType) {
12261 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
12262 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12263 vn_decode_VkPhysicalDevicePrivateDataFeatures_self(dec, (VkPhysicalDevicePrivateDataFeatures *)pnext);
12264 break;
12265 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
12266 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12267 vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(dec, (VkPhysicalDeviceVariablePointersFeatures *)pnext);
12268 break;
12269 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
12270 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12271 vn_decode_VkPhysicalDeviceMultiviewFeatures_self(dec, (VkPhysicalDeviceMultiviewFeatures *)pnext);
12272 break;
12273 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
12274 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12275 vn_decode_VkPhysicalDevice16BitStorageFeatures_self(dec, (VkPhysicalDevice16BitStorageFeatures *)pnext);
12276 break;
12277 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
12278 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12279 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(dec, (VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
12280 break;
12281 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
12282 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12283 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(dec, (VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
12284 break;
12285 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
12286 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12287 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(dec, (VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
12288 break;
12289 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
12290 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12291 vn_decode_VkPhysicalDeviceMultiDrawFeaturesEXT_self(dec, (VkPhysicalDeviceMultiDrawFeaturesEXT *)pnext);
12292 break;
12293 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
12294 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12295 vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures_self(dec, (VkPhysicalDeviceInlineUniformBlockFeatures *)pnext);
12296 break;
12297 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
12298 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12299 vn_decode_VkPhysicalDeviceMaintenance4Features_self(dec, (VkPhysicalDeviceMaintenance4Features *)pnext);
12300 break;
12301 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
12302 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12303 vn_decode_VkPhysicalDeviceMaintenance5FeaturesKHR_self(dec, (VkPhysicalDeviceMaintenance5FeaturesKHR *)pnext);
12304 break;
12305 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
12306 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12307 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(dec, (VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
12308 break;
12309 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
12310 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12311 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(dec, (VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
12312 break;
12313 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
12314 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12315 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(dec, (VkPhysicalDeviceHostQueryResetFeatures *)pnext);
12316 break;
12317 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
12318 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12319 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(dec, (VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
12320 break;
12321 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
12322 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12323 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(dec, (VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
12324 break;
12325 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
12326 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12327 vn_decode_VkPhysicalDevice8BitStorageFeatures_self(dec, (VkPhysicalDevice8BitStorageFeatures *)pnext);
12328 break;
12329 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
12330 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12331 vn_decode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(dec, (VkPhysicalDeviceConditionalRenderingFeaturesEXT *)pnext);
12332 break;
12333 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
12334 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12335 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(dec, (VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
12336 break;
12337 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
12338 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12339 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(dec, (VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
12340 break;
12341 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
12342 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12343 vn_decode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(dec, (VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)pnext);
12344 break;
12345 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
12346 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12347 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(dec, (VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
12348 break;
12349 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
12350 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12351 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(dec, (VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
12352 break;
12353 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
12354 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12355 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(dec, (VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
12356 break;
12357 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
12358 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12359 vn_decode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(dec, (VkPhysicalDeviceDepthClipEnableFeaturesEXT *)pnext);
12360 break;
12361 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
12362 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12363 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(dec, (VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
12364 break;
12365 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
12366 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12367 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(dec, (VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
12368 break;
12369 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
12370 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12371 vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(dec, (VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext);
12372 break;
12373 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
12374 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12375 vn_decode_VkPhysicalDeviceShaderClockFeaturesKHR_self(dec, (VkPhysicalDeviceShaderClockFeaturesKHR *)pnext);
12376 break;
12377 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
12378 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12379 vn_decode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(dec, (VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)pnext);
12380 break;
12381 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
12382 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12383 vn_decode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self(dec, (VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)pnext);
12384 break;
12385 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
12386 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12387 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(dec, (VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
12388 break;
12389 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
12390 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12391 vn_decode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self(dec, (VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)pnext);
12392 break;
12393 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
12394 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12395 vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(dec, (VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext);
12396 break;
12397 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
12398 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12399 vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(dec, (VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext);
12400 break;
12401 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
12402 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12403 vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(dec, (VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext);
12404 break;
12405 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
12406 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12407 vn_decode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(dec, (VkPhysicalDeviceLineRasterizationFeaturesEXT *)pnext);
12408 break;
12409 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
12410 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12411 vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(dec, (VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext);
12412 break;
12413 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
12414 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12415 vn_decode_VkPhysicalDeviceVulkan11Features_self(dec, (VkPhysicalDeviceVulkan11Features *)pnext);
12416 break;
12417 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
12418 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12419 vn_decode_VkPhysicalDeviceVulkan12Features_self(dec, (VkPhysicalDeviceVulkan12Features *)pnext);
12420 break;
12421 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
12422 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12423 vn_decode_VkPhysicalDeviceVulkan13Features_self(dec, (VkPhysicalDeviceVulkan13Features *)pnext);
12424 break;
12425 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
12426 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12427 vn_decode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(dec, (VkPhysicalDeviceCustomBorderColorFeaturesEXT *)pnext);
12428 break;
12429 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
12430 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12431 vn_decode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self(dec, (VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)pnext);
12432 break;
12433 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
12434 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12435 vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(dec, (VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext);
12436 break;
12437 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
12438 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12439 vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(dec, (VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext);
12440 break;
12441 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
12442 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12443 vn_decode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self(dec, (VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)pnext);
12444 break;
12445 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
12446 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12447 vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(dec, (VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext);
12448 break;
12449 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
12450 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12451 vn_decode_VkPhysicalDeviceRobustness2FeaturesEXT_self(dec, (VkPhysicalDeviceRobustness2FeaturesEXT *)pnext);
12452 break;
12453 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
12454 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12455 vn_decode_VkPhysicalDeviceImageRobustnessFeatures_self(dec, (VkPhysicalDeviceImageRobustnessFeatures *)pnext);
12456 break;
12457 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
12458 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12459 vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT_self(dec, (VkPhysicalDevice4444FormatsFeaturesEXT *)pnext);
12460 break;
12461 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
12462 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12463 vn_decode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self(dec, (VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)pnext);
12464 break;
12465 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
12466 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12467 vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(dec, (VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext);
12468 break;
12469 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
12470 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12471 vn_decode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self(dec, (VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)pnext);
12472 break;
12473 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
12474 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12475 vn_decode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self(dec, (VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)pnext);
12476 break;
12477 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
12478 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12479 vn_decode_VkPhysicalDeviceDepthClipControlFeaturesEXT_self(dec, (VkPhysicalDeviceDepthClipControlFeaturesEXT *)pnext);
12480 break;
12481 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
12482 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12483 vn_decode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self(dec, (VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)pnext);
12484 break;
12485 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
12486 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12487 vn_decode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self(dec, (VkPhysicalDeviceColorWriteEnableFeaturesEXT *)pnext);
12488 break;
12489 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
12490 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12491 vn_decode_VkPhysicalDeviceSynchronization2Features_self(dec, (VkPhysicalDeviceSynchronization2Features *)pnext);
12492 break;
12493 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
12494 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12495 vn_decode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self(dec, (VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)pnext);
12496 break;
12497 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
12498 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12499 vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(dec, (VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext);
12500 break;
12501 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
12502 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12503 vn_decode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(dec, (VkPhysicalDeviceProvokingVertexFeaturesEXT *)pnext);
12504 break;
12505 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
12506 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12507 vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(dec, (VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext);
12508 break;
12509 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
12510 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12511 vn_decode_VkPhysicalDeviceDynamicRenderingFeatures_self(dec, (VkPhysicalDeviceDynamicRenderingFeatures *)pnext);
12512 break;
12513 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
12514 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12515 vn_decode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(dec, (VkPhysicalDeviceImageViewMinLodFeaturesEXT *)pnext);
12516 break;
12517 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
12518 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12519 vn_decode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self(dec, (VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)pnext);
12520 break;
12521 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
12522 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12523 vn_decode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self(dec, (VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)pnext);
12524 break;
12525 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
12526 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12527 vn_decode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self(dec, (VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)pnext);
12528 break;
12529 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
12530 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12531 vn_decode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self(dec, (VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)pnext);
12532 break;
12533 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
12534 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
12535 vn_decode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self(dec, (VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)pnext);
12536 break;
12537 default:
12538 assert(false);
12539 break;
12540 }
12541 }
12542
12543 static inline void
vn_decode_VkPhysicalDeviceFeatures2_self(struct vn_cs_decoder * dec,VkPhysicalDeviceFeatures2 * val)12544 vn_decode_VkPhysicalDeviceFeatures2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures2 *val)
12545 {
12546 /* skip val->{sType,pNext} */
12547 vn_decode_VkPhysicalDeviceFeatures(dec, &val->features);
12548 }
12549
12550 static inline void
vn_decode_VkPhysicalDeviceFeatures2(struct vn_cs_decoder * dec,VkPhysicalDeviceFeatures2 * val)12551 vn_decode_VkPhysicalDeviceFeatures2(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures2 *val)
12552 {
12553 VkStructureType stype;
12554 vn_decode_VkStructureType(dec, &stype);
12555 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
12556
12557 assert(val->sType == stype);
12558 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, val->pNext);
12559 vn_decode_VkPhysicalDeviceFeatures2_self(dec, val);
12560 }
12561
12562 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(const void * val)12563 vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(const void *val)
12564 {
12565 const VkBaseInStructure *pnext = val;
12566 size_t size = 0;
12567
12568 while (pnext) {
12569 switch ((int32_t)pnext->sType) {
12570 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
12571 if (!vn_cs_renderer_protocol_has_extension(296 /* VK_EXT_private_data */))
12572 break;
12573 size += vn_sizeof_simple_pointer(pnext);
12574 size += vn_sizeof_VkStructureType(&pnext->sType);
12575 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12576 size += vn_sizeof_VkPhysicalDevicePrivateDataFeatures_self_partial((const VkPhysicalDevicePrivateDataFeatures *)pnext);
12577 return size;
12578 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
12579 size += vn_sizeof_simple_pointer(pnext);
12580 size += vn_sizeof_VkStructureType(&pnext->sType);
12581 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12582 size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial((const VkPhysicalDeviceVariablePointersFeatures *)pnext);
12583 return size;
12584 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
12585 size += vn_sizeof_simple_pointer(pnext);
12586 size += vn_sizeof_VkStructureType(&pnext->sType);
12587 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12588 size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial((const VkPhysicalDeviceMultiviewFeatures *)pnext);
12589 return size;
12590 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
12591 size += vn_sizeof_simple_pointer(pnext);
12592 size += vn_sizeof_VkStructureType(&pnext->sType);
12593 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12594 size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial((const VkPhysicalDevice16BitStorageFeatures *)pnext);
12595 return size;
12596 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
12597 size += vn_sizeof_simple_pointer(pnext);
12598 size += vn_sizeof_VkStructureType(&pnext->sType);
12599 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12600 size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
12601 return size;
12602 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
12603 size += vn_sizeof_simple_pointer(pnext);
12604 size += vn_sizeof_VkStructureType(&pnext->sType);
12605 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12606 size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
12607 return size;
12608 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
12609 size += vn_sizeof_simple_pointer(pnext);
12610 size += vn_sizeof_VkStructureType(&pnext->sType);
12611 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12612 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
12613 return size;
12614 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
12615 if (!vn_cs_renderer_protocol_has_extension(393 /* VK_EXT_multi_draw */))
12616 break;
12617 size += vn_sizeof_simple_pointer(pnext);
12618 size += vn_sizeof_VkStructureType(&pnext->sType);
12619 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12620 size += vn_sizeof_VkPhysicalDeviceMultiDrawFeaturesEXT_self_partial((const VkPhysicalDeviceMultiDrawFeaturesEXT *)pnext);
12621 return size;
12622 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
12623 if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
12624 break;
12625 size += vn_sizeof_simple_pointer(pnext);
12626 size += vn_sizeof_VkStructureType(&pnext->sType);
12627 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12628 size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial((const VkPhysicalDeviceInlineUniformBlockFeatures *)pnext);
12629 return size;
12630 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
12631 if (!vn_cs_renderer_protocol_has_extension(414 /* VK_KHR_maintenance4 */))
12632 break;
12633 size += vn_sizeof_simple_pointer(pnext);
12634 size += vn_sizeof_VkStructureType(&pnext->sType);
12635 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12636 size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_self_partial((const VkPhysicalDeviceMaintenance4Features *)pnext);
12637 return size;
12638 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
12639 if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
12640 break;
12641 size += vn_sizeof_simple_pointer(pnext);
12642 size += vn_sizeof_VkStructureType(&pnext->sType);
12643 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12644 size += vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_self_partial((const VkPhysicalDeviceMaintenance5FeaturesKHR *)pnext);
12645 return size;
12646 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
12647 size += vn_sizeof_simple_pointer(pnext);
12648 size += vn_sizeof_VkStructureType(&pnext->sType);
12649 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12650 size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
12651 return size;
12652 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
12653 size += vn_sizeof_simple_pointer(pnext);
12654 size += vn_sizeof_VkStructureType(&pnext->sType);
12655 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12656 size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
12657 return size;
12658 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
12659 size += vn_sizeof_simple_pointer(pnext);
12660 size += vn_sizeof_VkStructureType(&pnext->sType);
12661 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12662 size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial((const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
12663 return size;
12664 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
12665 size += vn_sizeof_simple_pointer(pnext);
12666 size += vn_sizeof_VkStructureType(&pnext->sType);
12667 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12668 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
12669 return size;
12670 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
12671 size += vn_sizeof_simple_pointer(pnext);
12672 size += vn_sizeof_VkStructureType(&pnext->sType);
12673 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12674 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
12675 return size;
12676 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
12677 size += vn_sizeof_simple_pointer(pnext);
12678 size += vn_sizeof_VkStructureType(&pnext->sType);
12679 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12680 size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial((const VkPhysicalDevice8BitStorageFeatures *)pnext);
12681 return size;
12682 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
12683 if (!vn_cs_renderer_protocol_has_extension(82 /* VK_EXT_conditional_rendering */))
12684 break;
12685 size += vn_sizeof_simple_pointer(pnext);
12686 size += vn_sizeof_VkStructureType(&pnext->sType);
12687 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12688 size += vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self_partial((const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)pnext);
12689 return size;
12690 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
12691 size += vn_sizeof_simple_pointer(pnext);
12692 size += vn_sizeof_VkStructureType(&pnext->sType);
12693 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12694 size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
12695 return size;
12696 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
12697 size += vn_sizeof_simple_pointer(pnext);
12698 size += vn_sizeof_VkStructureType(&pnext->sType);
12699 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12700 size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
12701 return size;
12702 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
12703 if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
12704 break;
12705 size += vn_sizeof_simple_pointer(pnext);
12706 size += vn_sizeof_VkStructureType(&pnext->sType);
12707 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12708 size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self_partial((const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)pnext);
12709 return size;
12710 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
12711 if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
12712 break;
12713 size += vn_sizeof_simple_pointer(pnext);
12714 size += vn_sizeof_VkStructureType(&pnext->sType);
12715 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12716 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
12717 return size;
12718 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
12719 size += vn_sizeof_simple_pointer(pnext);
12720 size += vn_sizeof_VkStructureType(&pnext->sType);
12721 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12722 size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
12723 return size;
12724 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
12725 size += vn_sizeof_simple_pointer(pnext);
12726 size += vn_sizeof_VkStructureType(&pnext->sType);
12727 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12728 size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
12729 return size;
12730 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
12731 if (!vn_cs_renderer_protocol_has_extension(103 /* VK_EXT_depth_clip_enable */))
12732 break;
12733 size += vn_sizeof_simple_pointer(pnext);
12734 size += vn_sizeof_VkStructureType(&pnext->sType);
12735 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12736 size += vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self_partial((const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)pnext);
12737 return size;
12738 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
12739 size += vn_sizeof_simple_pointer(pnext);
12740 size += vn_sizeof_VkStructureType(&pnext->sType);
12741 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12742 size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
12743 return size;
12744 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
12745 size += vn_sizeof_simple_pointer(pnext);
12746 size += vn_sizeof_VkStructureType(&pnext->sType);
12747 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12748 size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
12749 return size;
12750 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
12751 if (!vn_cs_renderer_protocol_has_extension(67 /* VK_EXT_texture_compression_astc_hdr */))
12752 break;
12753 size += vn_sizeof_simple_pointer(pnext);
12754 size += vn_sizeof_VkStructureType(&pnext->sType);
12755 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12756 size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial((const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext);
12757 return size;
12758 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
12759 if (!vn_cs_renderer_protocol_has_extension(182 /* VK_KHR_shader_clock */))
12760 break;
12761 size += vn_sizeof_simple_pointer(pnext);
12762 size += vn_sizeof_VkStructureType(&pnext->sType);
12763 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12764 size += vn_sizeof_VkPhysicalDeviceShaderClockFeaturesKHR_self_partial((const VkPhysicalDeviceShaderClockFeaturesKHR *)pnext);
12765 return size;
12766 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
12767 if (!vn_cs_renderer_protocol_has_extension(266 /* VK_EXT_index_type_uint8 */))
12768 break;
12769 size += vn_sizeof_simple_pointer(pnext);
12770 size += vn_sizeof_VkStructureType(&pnext->sType);
12771 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12772 size += vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self_partial((const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)pnext);
12773 return size;
12774 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
12775 if (!vn_cs_renderer_protocol_has_extension(252 /* VK_EXT_fragment_shader_interlock */))
12776 break;
12777 size += vn_sizeof_simple_pointer(pnext);
12778 size += vn_sizeof_VkStructureType(&pnext->sType);
12779 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12780 size += vn_sizeof_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self_partial((const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)pnext);
12781 return size;
12782 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
12783 size += vn_sizeof_simple_pointer(pnext);
12784 size += vn_sizeof_VkStructureType(&pnext->sType);
12785 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12786 size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
12787 return size;
12788 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
12789 if (!vn_cs_renderer_protocol_has_extension(357 /* VK_EXT_primitive_topology_list_restart */))
12790 break;
12791 size += vn_sizeof_simple_pointer(pnext);
12792 size += vn_sizeof_VkStructureType(&pnext->sType);
12793 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12794 size += vn_sizeof_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self_partial((const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)pnext);
12795 return size;
12796 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
12797 if (!vn_cs_renderer_protocol_has_extension(277 /* VK_EXT_shader_demote_to_helper_invocation */))
12798 break;
12799 size += vn_sizeof_simple_pointer(pnext);
12800 size += vn_sizeof_VkStructureType(&pnext->sType);
12801 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12802 size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial((const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext);
12803 return size;
12804 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
12805 if (!vn_cs_renderer_protocol_has_extension(282 /* VK_EXT_texel_buffer_alignment */))
12806 break;
12807 size += vn_sizeof_simple_pointer(pnext);
12808 size += vn_sizeof_VkStructureType(&pnext->sType);
12809 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12810 size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial((const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext);
12811 return size;
12812 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
12813 if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
12814 break;
12815 size += vn_sizeof_simple_pointer(pnext);
12816 size += vn_sizeof_VkStructureType(&pnext->sType);
12817 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12818 size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial((const VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext);
12819 return size;
12820 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
12821 if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
12822 break;
12823 size += vn_sizeof_simple_pointer(pnext);
12824 size += vn_sizeof_VkStructureType(&pnext->sType);
12825 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12826 size += vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_self_partial((const VkPhysicalDeviceLineRasterizationFeaturesEXT *)pnext);
12827 return size;
12828 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
12829 if (!vn_cs_renderer_protocol_has_extension(298 /* VK_EXT_pipeline_creation_cache_control */))
12830 break;
12831 size += vn_sizeof_simple_pointer(pnext);
12832 size += vn_sizeof_VkStructureType(&pnext->sType);
12833 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12834 size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial((const VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext);
12835 return size;
12836 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
12837 size += vn_sizeof_simple_pointer(pnext);
12838 size += vn_sizeof_VkStructureType(&pnext->sType);
12839 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12840 size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial((const VkPhysicalDeviceVulkan11Features *)pnext);
12841 return size;
12842 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
12843 size += vn_sizeof_simple_pointer(pnext);
12844 size += vn_sizeof_VkStructureType(&pnext->sType);
12845 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12846 size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial((const VkPhysicalDeviceVulkan12Features *)pnext);
12847 return size;
12848 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
12849 if (!vn_cs_renderer_protocol_has_api_version(VK_API_VERSION_1_3))
12850 break;
12851 size += vn_sizeof_simple_pointer(pnext);
12852 size += vn_sizeof_VkStructureType(&pnext->sType);
12853 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12854 size += vn_sizeof_VkPhysicalDeviceVulkan13Features_self_partial((const VkPhysicalDeviceVulkan13Features *)pnext);
12855 return size;
12856 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
12857 if (!vn_cs_renderer_protocol_has_extension(288 /* VK_EXT_custom_border_color */))
12858 break;
12859 size += vn_sizeof_simple_pointer(pnext);
12860 size += vn_sizeof_VkStructureType(&pnext->sType);
12861 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12862 size += vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self_partial((const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)pnext);
12863 return size;
12864 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
12865 if (!vn_cs_renderer_protocol_has_extension(412 /* VK_EXT_border_color_swizzle */))
12866 break;
12867 size += vn_sizeof_simple_pointer(pnext);
12868 size += vn_sizeof_VkStructureType(&pnext->sType);
12869 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12870 size += vn_sizeof_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self_partial((const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)pnext);
12871 return size;
12872 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
12873 if (!vn_cs_renderer_protocol_has_extension(268 /* VK_EXT_extended_dynamic_state */))
12874 break;
12875 size += vn_sizeof_simple_pointer(pnext);
12876 size += vn_sizeof_VkStructureType(&pnext->sType);
12877 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12878 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial((const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext);
12879 return size;
12880 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
12881 if (!vn_cs_renderer_protocol_has_extension(378 /* VK_EXT_extended_dynamic_state2 */))
12882 break;
12883 size += vn_sizeof_simple_pointer(pnext);
12884 size += vn_sizeof_VkStructureType(&pnext->sType);
12885 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12886 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial((const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext);
12887 return size;
12888 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
12889 if (!vn_cs_renderer_protocol_has_extension(456 /* VK_EXT_extended_dynamic_state3 */))
12890 break;
12891 size += vn_sizeof_simple_pointer(pnext);
12892 size += vn_sizeof_VkStructureType(&pnext->sType);
12893 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12894 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self_partial((const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)pnext);
12895 return size;
12896 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
12897 if (!vn_cs_renderer_protocol_has_extension(326 /* VK_KHR_zero_initialize_workgroup_memory */))
12898 break;
12899 size += vn_sizeof_simple_pointer(pnext);
12900 size += vn_sizeof_VkStructureType(&pnext->sType);
12901 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12902 size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial((const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext);
12903 return size;
12904 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
12905 if (!vn_cs_renderer_protocol_has_extension(287 /* VK_EXT_robustness2 */))
12906 break;
12907 size += vn_sizeof_simple_pointer(pnext);
12908 size += vn_sizeof_VkStructureType(&pnext->sType);
12909 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12910 size += vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_self_partial((const VkPhysicalDeviceRobustness2FeaturesEXT *)pnext);
12911 return size;
12912 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
12913 if (!vn_cs_renderer_protocol_has_extension(336 /* VK_EXT_image_robustness */))
12914 break;
12915 size += vn_sizeof_simple_pointer(pnext);
12916 size += vn_sizeof_VkStructureType(&pnext->sType);
12917 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12918 size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self_partial((const VkPhysicalDeviceImageRobustnessFeatures *)pnext);
12919 return size;
12920 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
12921 if (!vn_cs_renderer_protocol_has_extension(341 /* VK_EXT_4444_formats */))
12922 break;
12923 size += vn_sizeof_simple_pointer(pnext);
12924 size += vn_sizeof_VkStructureType(&pnext->sType);
12925 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12926 size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial((const VkPhysicalDevice4444FormatsFeaturesEXT *)pnext);
12927 return size;
12928 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
12929 if (!vn_cs_renderer_protocol_has_extension(227 /* VK_KHR_fragment_shading_rate */))
12930 break;
12931 size += vn_sizeof_simple_pointer(pnext);
12932 size += vn_sizeof_VkStructureType(&pnext->sType);
12933 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12934 size += vn_sizeof_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self_partial((const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)pnext);
12935 return size;
12936 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
12937 if (!vn_cs_renderer_protocol_has_extension(216 /* VK_KHR_shader_terminate_invocation */))
12938 break;
12939 size += vn_sizeof_simple_pointer(pnext);
12940 size += vn_sizeof_VkStructureType(&pnext->sType);
12941 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12942 size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial((const VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext);
12943 return size;
12944 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
12945 if (!vn_cs_renderer_protocol_has_extension(394 /* VK_EXT_image_2d_view_of_3d */))
12946 break;
12947 size += vn_sizeof_simple_pointer(pnext);
12948 size += vn_sizeof_VkStructureType(&pnext->sType);
12949 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12950 size += vn_sizeof_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self_partial((const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)pnext);
12951 return size;
12952 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
12953 if (!vn_cs_renderer_protocol_has_extension(352 /* VK_VALVE_mutable_descriptor_type */) && !vn_cs_renderer_protocol_has_extension(495 /* VK_EXT_mutable_descriptor_type */))
12954 break;
12955 size += vn_sizeof_simple_pointer(pnext);
12956 size += vn_sizeof_VkStructureType(&pnext->sType);
12957 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12958 size += vn_sizeof_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self_partial((const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)pnext);
12959 return size;
12960 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
12961 if (!vn_cs_renderer_protocol_has_extension(356 /* VK_EXT_depth_clip_control */))
12962 break;
12963 size += vn_sizeof_simple_pointer(pnext);
12964 size += vn_sizeof_VkStructureType(&pnext->sType);
12965 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12966 size += vn_sizeof_VkPhysicalDeviceDepthClipControlFeaturesEXT_self_partial((const VkPhysicalDeviceDepthClipControlFeaturesEXT *)pnext);
12967 return size;
12968 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
12969 if (!vn_cs_renderer_protocol_has_extension(353 /* VK_EXT_vertex_input_dynamic_state */))
12970 break;
12971 size += vn_sizeof_simple_pointer(pnext);
12972 size += vn_sizeof_VkStructureType(&pnext->sType);
12973 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12974 size += vn_sizeof_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self_partial((const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)pnext);
12975 return size;
12976 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
12977 if (!vn_cs_renderer_protocol_has_extension(382 /* VK_EXT_color_write_enable */))
12978 break;
12979 size += vn_sizeof_simple_pointer(pnext);
12980 size += vn_sizeof_VkStructureType(&pnext->sType);
12981 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12982 size += vn_sizeof_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self_partial((const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)pnext);
12983 return size;
12984 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
12985 if (!vn_cs_renderer_protocol_has_extension(315 /* VK_KHR_synchronization2 */))
12986 break;
12987 size += vn_sizeof_simple_pointer(pnext);
12988 size += vn_sizeof_VkStructureType(&pnext->sType);
12989 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12990 size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_self_partial((const VkPhysicalDeviceSynchronization2Features *)pnext);
12991 return size;
12992 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
12993 if (!vn_cs_renderer_protocol_has_extension(383 /* VK_EXT_primitives_generated_query */))
12994 break;
12995 size += vn_sizeof_simple_pointer(pnext);
12996 size += vn_sizeof_VkStructureType(&pnext->sType);
12997 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
12998 size += vn_sizeof_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self_partial((const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)pnext);
12999 return size;
13000 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
13001 if (!vn_cs_renderer_protocol_has_extension(331 /* VK_EXT_ycbcr_2plane_444_formats */))
13002 break;
13003 size += vn_sizeof_simple_pointer(pnext);
13004 size += vn_sizeof_VkStructureType(&pnext->sType);
13005 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
13006 size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial((const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext);
13007 return size;
13008 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
13009 if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
13010 break;
13011 size += vn_sizeof_simple_pointer(pnext);
13012 size += vn_sizeof_VkStructureType(&pnext->sType);
13013 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
13014 size += vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_self_partial((const VkPhysicalDeviceProvokingVertexFeaturesEXT *)pnext);
13015 return size;
13016 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
13017 if (!vn_cs_renderer_protocol_has_extension(281 /* VK_KHR_shader_integer_dot_product */))
13018 break;
13019 size += vn_sizeof_simple_pointer(pnext);
13020 size += vn_sizeof_VkStructureType(&pnext->sType);
13021 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
13022 size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial((const VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext);
13023 return size;
13024 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
13025 if (!vn_cs_renderer_protocol_has_extension(45 /* VK_KHR_dynamic_rendering */))
13026 break;
13027 size += vn_sizeof_simple_pointer(pnext);
13028 size += vn_sizeof_VkStructureType(&pnext->sType);
13029 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
13030 size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self_partial((const VkPhysicalDeviceDynamicRenderingFeatures *)pnext);
13031 return size;
13032 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
13033 if (!vn_cs_renderer_protocol_has_extension(392 /* VK_EXT_image_view_min_lod */))
13034 break;
13035 size += vn_sizeof_simple_pointer(pnext);
13036 size += vn_sizeof_VkStructureType(&pnext->sType);
13037 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
13038 size += vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self_partial((const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)pnext);
13039 return size;
13040 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
13041 if (!vn_cs_renderer_protocol_has_extension(464 /* VK_EXT_rasterization_order_attachment_access */))
13042 break;
13043 size += vn_sizeof_simple_pointer(pnext);
13044 size += vn_sizeof_VkStructureType(&pnext->sType);
13045 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
13046 size += vn_sizeof_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self_partial((const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)pnext);
13047 return size;
13048 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
13049 if (!vn_cs_renderer_protocol_has_extension(321 /* VK_EXT_graphics_pipeline_library */))
13050 break;
13051 size += vn_sizeof_simple_pointer(pnext);
13052 size += vn_sizeof_VkStructureType(&pnext->sType);
13053 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
13054 size += vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self_partial((const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)pnext);
13055 return size;
13056 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
13057 if (!vn_cs_renderer_protocol_has_extension(423 /* VK_EXT_non_seamless_cube_map */))
13058 break;
13059 size += vn_sizeof_simple_pointer(pnext);
13060 size += vn_sizeof_VkStructureType(&pnext->sType);
13061 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
13062 size += vn_sizeof_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self_partial((const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)pnext);
13063 return size;
13064 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
13065 if (!vn_cs_renderer_protocol_has_extension(340 /* VK_EXT_attachment_feedback_loop_layout */))
13066 break;
13067 size += vn_sizeof_simple_pointer(pnext);
13068 size += vn_sizeof_VkStructureType(&pnext->sType);
13069 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
13070 size += vn_sizeof_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self_partial((const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)pnext);
13071 return size;
13072 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
13073 if (!vn_cs_renderer_protocol_has_extension(500 /* VK_EXT_dynamic_rendering_unused_attachments */))
13074 break;
13075 size += vn_sizeof_simple_pointer(pnext);
13076 size += vn_sizeof_VkStructureType(&pnext->sType);
13077 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
13078 size += vn_sizeof_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self_partial((const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)pnext);
13079 return size;
13080 default:
13081 /* ignore unknown/unsupported struct */
13082 break;
13083 }
13084 pnext = pnext->pNext;
13085 }
13086
13087 return vn_sizeof_simple_pointer(NULL);
13088 }
13089
13090 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_self_partial(const VkPhysicalDeviceFeatures2 * val)13091 vn_sizeof_VkPhysicalDeviceFeatures2_self_partial(const VkPhysicalDeviceFeatures2 *val)
13092 {
13093 size_t size = 0;
13094 /* skip val->{sType,pNext} */
13095 size += vn_sizeof_VkPhysicalDeviceFeatures_partial(&val->features);
13096 return size;
13097 }
13098
13099 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_partial(const VkPhysicalDeviceFeatures2 * val)13100 vn_sizeof_VkPhysicalDeviceFeatures2_partial(const VkPhysicalDeviceFeatures2 *val)
13101 {
13102 size_t size = 0;
13103
13104 size += vn_sizeof_VkStructureType(&val->sType);
13105 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(val->pNext);
13106 size += vn_sizeof_VkPhysicalDeviceFeatures2_self_partial(val);
13107
13108 return size;
13109 }
13110
13111 static inline void
vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(struct vn_cs_encoder * enc,const void * val)13112 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
13113 {
13114 const VkBaseInStructure *pnext = val;
13115
13116 while (pnext) {
13117 switch ((int32_t)pnext->sType) {
13118 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
13119 if (!vn_cs_renderer_protocol_has_extension(296 /* VK_EXT_private_data */))
13120 break;
13121 vn_encode_simple_pointer(enc, pnext);
13122 vn_encode_VkStructureType(enc, &pnext->sType);
13123 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13124 vn_encode_VkPhysicalDevicePrivateDataFeatures_self_partial(enc, (const VkPhysicalDevicePrivateDataFeatures *)pnext);
13125 return;
13126 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
13127 vn_encode_simple_pointer(enc, pnext);
13128 vn_encode_VkStructureType(enc, &pnext->sType);
13129 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13130 vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext);
13131 return;
13132 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
13133 vn_encode_simple_pointer(enc, pnext);
13134 vn_encode_VkStructureType(enc, &pnext->sType);
13135 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13136 vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext);
13137 return;
13138 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
13139 vn_encode_simple_pointer(enc, pnext);
13140 vn_encode_VkStructureType(enc, &pnext->sType);
13141 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13142 vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext);
13143 return;
13144 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
13145 vn_encode_simple_pointer(enc, pnext);
13146 vn_encode_VkStructureType(enc, &pnext->sType);
13147 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13148 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
13149 return;
13150 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
13151 vn_encode_simple_pointer(enc, pnext);
13152 vn_encode_VkStructureType(enc, &pnext->sType);
13153 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13154 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
13155 return;
13156 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
13157 vn_encode_simple_pointer(enc, pnext);
13158 vn_encode_VkStructureType(enc, &pnext->sType);
13159 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13160 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
13161 return;
13162 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
13163 if (!vn_cs_renderer_protocol_has_extension(393 /* VK_EXT_multi_draw */))
13164 break;
13165 vn_encode_simple_pointer(enc, pnext);
13166 vn_encode_VkStructureType(enc, &pnext->sType);
13167 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13168 vn_encode_VkPhysicalDeviceMultiDrawFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceMultiDrawFeaturesEXT *)pnext);
13169 return;
13170 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
13171 if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
13172 break;
13173 vn_encode_simple_pointer(enc, pnext);
13174 vn_encode_VkStructureType(enc, &pnext->sType);
13175 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13176 vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial(enc, (const VkPhysicalDeviceInlineUniformBlockFeatures *)pnext);
13177 return;
13178 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
13179 if (!vn_cs_renderer_protocol_has_extension(414 /* VK_KHR_maintenance4 */))
13180 break;
13181 vn_encode_simple_pointer(enc, pnext);
13182 vn_encode_VkStructureType(enc, &pnext->sType);
13183 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13184 vn_encode_VkPhysicalDeviceMaintenance4Features_self_partial(enc, (const VkPhysicalDeviceMaintenance4Features *)pnext);
13185 return;
13186 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
13187 if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
13188 break;
13189 vn_encode_simple_pointer(enc, pnext);
13190 vn_encode_VkStructureType(enc, &pnext->sType);
13191 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13192 vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_self_partial(enc, (const VkPhysicalDeviceMaintenance5FeaturesKHR *)pnext);
13193 return;
13194 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
13195 vn_encode_simple_pointer(enc, pnext);
13196 vn_encode_VkStructureType(enc, &pnext->sType);
13197 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13198 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
13199 return;
13200 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
13201 vn_encode_simple_pointer(enc, pnext);
13202 vn_encode_VkStructureType(enc, &pnext->sType);
13203 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13204 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
13205 return;
13206 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
13207 vn_encode_simple_pointer(enc, pnext);
13208 vn_encode_VkStructureType(enc, &pnext->sType);
13209 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13210 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
13211 return;
13212 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
13213 vn_encode_simple_pointer(enc, pnext);
13214 vn_encode_VkStructureType(enc, &pnext->sType);
13215 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13216 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
13217 return;
13218 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
13219 vn_encode_simple_pointer(enc, pnext);
13220 vn_encode_VkStructureType(enc, &pnext->sType);
13221 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13222 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
13223 return;
13224 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
13225 vn_encode_simple_pointer(enc, pnext);
13226 vn_encode_VkStructureType(enc, &pnext->sType);
13227 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13228 vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext);
13229 return;
13230 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
13231 if (!vn_cs_renderer_protocol_has_extension(82 /* VK_EXT_conditional_rendering */))
13232 break;
13233 vn_encode_simple_pointer(enc, pnext);
13234 vn_encode_VkStructureType(enc, &pnext->sType);
13235 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13236 vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)pnext);
13237 return;
13238 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
13239 vn_encode_simple_pointer(enc, pnext);
13240 vn_encode_VkStructureType(enc, &pnext->sType);
13241 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13242 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
13243 return;
13244 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
13245 vn_encode_simple_pointer(enc, pnext);
13246 vn_encode_VkStructureType(enc, &pnext->sType);
13247 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13248 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
13249 return;
13250 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
13251 if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
13252 break;
13253 vn_encode_simple_pointer(enc, pnext);
13254 vn_encode_VkStructureType(enc, &pnext->sType);
13255 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13256 vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)pnext);
13257 return;
13258 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
13259 if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
13260 break;
13261 vn_encode_simple_pointer(enc, pnext);
13262 vn_encode_VkStructureType(enc, &pnext->sType);
13263 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13264 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
13265 return;
13266 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
13267 vn_encode_simple_pointer(enc, pnext);
13268 vn_encode_VkStructureType(enc, &pnext->sType);
13269 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13270 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
13271 return;
13272 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
13273 vn_encode_simple_pointer(enc, pnext);
13274 vn_encode_VkStructureType(enc, &pnext->sType);
13275 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13276 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
13277 return;
13278 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
13279 if (!vn_cs_renderer_protocol_has_extension(103 /* VK_EXT_depth_clip_enable */))
13280 break;
13281 vn_encode_simple_pointer(enc, pnext);
13282 vn_encode_VkStructureType(enc, &pnext->sType);
13283 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13284 vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)pnext);
13285 return;
13286 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
13287 vn_encode_simple_pointer(enc, pnext);
13288 vn_encode_VkStructureType(enc, &pnext->sType);
13289 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13290 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
13291 return;
13292 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
13293 vn_encode_simple_pointer(enc, pnext);
13294 vn_encode_VkStructureType(enc, &pnext->sType);
13295 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13296 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
13297 return;
13298 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
13299 if (!vn_cs_renderer_protocol_has_extension(67 /* VK_EXT_texture_compression_astc_hdr */))
13300 break;
13301 vn_encode_simple_pointer(enc, pnext);
13302 vn_encode_VkStructureType(enc, &pnext->sType);
13303 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13304 vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial(enc, (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext);
13305 return;
13306 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
13307 if (!vn_cs_renderer_protocol_has_extension(182 /* VK_KHR_shader_clock */))
13308 break;
13309 vn_encode_simple_pointer(enc, pnext);
13310 vn_encode_VkStructureType(enc, &pnext->sType);
13311 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13312 vn_encode_VkPhysicalDeviceShaderClockFeaturesKHR_self_partial(enc, (const VkPhysicalDeviceShaderClockFeaturesKHR *)pnext);
13313 return;
13314 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
13315 if (!vn_cs_renderer_protocol_has_extension(266 /* VK_EXT_index_type_uint8 */))
13316 break;
13317 vn_encode_simple_pointer(enc, pnext);
13318 vn_encode_VkStructureType(enc, &pnext->sType);
13319 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13320 vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self_partial(enc, (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)pnext);
13321 return;
13322 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
13323 if (!vn_cs_renderer_protocol_has_extension(252 /* VK_EXT_fragment_shader_interlock */))
13324 break;
13325 vn_encode_simple_pointer(enc, pnext);
13326 vn_encode_VkStructureType(enc, &pnext->sType);
13327 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13328 vn_encode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)pnext);
13329 return;
13330 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
13331 vn_encode_simple_pointer(enc, pnext);
13332 vn_encode_VkStructureType(enc, &pnext->sType);
13333 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13334 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
13335 return;
13336 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
13337 if (!vn_cs_renderer_protocol_has_extension(357 /* VK_EXT_primitive_topology_list_restart */))
13338 break;
13339 vn_encode_simple_pointer(enc, pnext);
13340 vn_encode_VkStructureType(enc, &pnext->sType);
13341 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13342 vn_encode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self_partial(enc, (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)pnext);
13343 return;
13344 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
13345 if (!vn_cs_renderer_protocol_has_extension(277 /* VK_EXT_shader_demote_to_helper_invocation */))
13346 break;
13347 vn_encode_simple_pointer(enc, pnext);
13348 vn_encode_VkStructureType(enc, &pnext->sType);
13349 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13350 vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial(enc, (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext);
13351 return;
13352 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
13353 if (!vn_cs_renderer_protocol_has_extension(282 /* VK_EXT_texel_buffer_alignment */))
13354 break;
13355 vn_encode_simple_pointer(enc, pnext);
13356 vn_encode_VkStructureType(enc, &pnext->sType);
13357 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13358 vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext);
13359 return;
13360 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
13361 if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
13362 break;
13363 vn_encode_simple_pointer(enc, pnext);
13364 vn_encode_VkStructureType(enc, &pnext->sType);
13365 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13366 vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial(enc, (const VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext);
13367 return;
13368 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
13369 if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
13370 break;
13371 vn_encode_simple_pointer(enc, pnext);
13372 vn_encode_VkStructureType(enc, &pnext->sType);
13373 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13374 vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)pnext);
13375 return;
13376 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
13377 if (!vn_cs_renderer_protocol_has_extension(298 /* VK_EXT_pipeline_creation_cache_control */))
13378 break;
13379 vn_encode_simple_pointer(enc, pnext);
13380 vn_encode_VkStructureType(enc, &pnext->sType);
13381 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13382 vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial(enc, (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext);
13383 return;
13384 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
13385 vn_encode_simple_pointer(enc, pnext);
13386 vn_encode_VkStructureType(enc, &pnext->sType);
13387 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13388 vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(enc, (const VkPhysicalDeviceVulkan11Features *)pnext);
13389 return;
13390 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
13391 vn_encode_simple_pointer(enc, pnext);
13392 vn_encode_VkStructureType(enc, &pnext->sType);
13393 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13394 vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(enc, (const VkPhysicalDeviceVulkan12Features *)pnext);
13395 return;
13396 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
13397 if (!vn_cs_renderer_protocol_has_api_version(VK_API_VERSION_1_3))
13398 break;
13399 vn_encode_simple_pointer(enc, pnext);
13400 vn_encode_VkStructureType(enc, &pnext->sType);
13401 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13402 vn_encode_VkPhysicalDeviceVulkan13Features_self_partial(enc, (const VkPhysicalDeviceVulkan13Features *)pnext);
13403 return;
13404 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
13405 if (!vn_cs_renderer_protocol_has_extension(288 /* VK_EXT_custom_border_color */))
13406 break;
13407 vn_encode_simple_pointer(enc, pnext);
13408 vn_encode_VkStructureType(enc, &pnext->sType);
13409 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13410 vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)pnext);
13411 return;
13412 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
13413 if (!vn_cs_renderer_protocol_has_extension(412 /* VK_EXT_border_color_swizzle */))
13414 break;
13415 vn_encode_simple_pointer(enc, pnext);
13416 vn_encode_VkStructureType(enc, &pnext->sType);
13417 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13418 vn_encode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)pnext);
13419 return;
13420 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
13421 if (!vn_cs_renderer_protocol_has_extension(268 /* VK_EXT_extended_dynamic_state */))
13422 break;
13423 vn_encode_simple_pointer(enc, pnext);
13424 vn_encode_VkStructureType(enc, &pnext->sType);
13425 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13426 vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext);
13427 return;
13428 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
13429 if (!vn_cs_renderer_protocol_has_extension(378 /* VK_EXT_extended_dynamic_state2 */))
13430 break;
13431 vn_encode_simple_pointer(enc, pnext);
13432 vn_encode_VkStructureType(enc, &pnext->sType);
13433 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13434 vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial(enc, (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext);
13435 return;
13436 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
13437 if (!vn_cs_renderer_protocol_has_extension(456 /* VK_EXT_extended_dynamic_state3 */))
13438 break;
13439 vn_encode_simple_pointer(enc, pnext);
13440 vn_encode_VkStructureType(enc, &pnext->sType);
13441 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13442 vn_encode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self_partial(enc, (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)pnext);
13443 return;
13444 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
13445 if (!vn_cs_renderer_protocol_has_extension(326 /* VK_KHR_zero_initialize_workgroup_memory */))
13446 break;
13447 vn_encode_simple_pointer(enc, pnext);
13448 vn_encode_VkStructureType(enc, &pnext->sType);
13449 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13450 vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial(enc, (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext);
13451 return;
13452 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
13453 if (!vn_cs_renderer_protocol_has_extension(287 /* VK_EXT_robustness2 */))
13454 break;
13455 vn_encode_simple_pointer(enc, pnext);
13456 vn_encode_VkStructureType(enc, &pnext->sType);
13457 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13458 vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_self_partial(enc, (const VkPhysicalDeviceRobustness2FeaturesEXT *)pnext);
13459 return;
13460 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
13461 if (!vn_cs_renderer_protocol_has_extension(336 /* VK_EXT_image_robustness */))
13462 break;
13463 vn_encode_simple_pointer(enc, pnext);
13464 vn_encode_VkStructureType(enc, &pnext->sType);
13465 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13466 vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self_partial(enc, (const VkPhysicalDeviceImageRobustnessFeatures *)pnext);
13467 return;
13468 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
13469 if (!vn_cs_renderer_protocol_has_extension(341 /* VK_EXT_4444_formats */))
13470 break;
13471 vn_encode_simple_pointer(enc, pnext);
13472 vn_encode_VkStructureType(enc, &pnext->sType);
13473 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13474 vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial(enc, (const VkPhysicalDevice4444FormatsFeaturesEXT *)pnext);
13475 return;
13476 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
13477 if (!vn_cs_renderer_protocol_has_extension(227 /* VK_KHR_fragment_shading_rate */))
13478 break;
13479 vn_encode_simple_pointer(enc, pnext);
13480 vn_encode_VkStructureType(enc, &pnext->sType);
13481 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13482 vn_encode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self_partial(enc, (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)pnext);
13483 return;
13484 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
13485 if (!vn_cs_renderer_protocol_has_extension(216 /* VK_KHR_shader_terminate_invocation */))
13486 break;
13487 vn_encode_simple_pointer(enc, pnext);
13488 vn_encode_VkStructureType(enc, &pnext->sType);
13489 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13490 vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial(enc, (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext);
13491 return;
13492 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
13493 if (!vn_cs_renderer_protocol_has_extension(394 /* VK_EXT_image_2d_view_of_3d */))
13494 break;
13495 vn_encode_simple_pointer(enc, pnext);
13496 vn_encode_VkStructureType(enc, &pnext->sType);
13497 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13498 vn_encode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)pnext);
13499 return;
13500 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
13501 if (!vn_cs_renderer_protocol_has_extension(352 /* VK_VALVE_mutable_descriptor_type */) && !vn_cs_renderer_protocol_has_extension(495 /* VK_EXT_mutable_descriptor_type */))
13502 break;
13503 vn_encode_simple_pointer(enc, pnext);
13504 vn_encode_VkStructureType(enc, &pnext->sType);
13505 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13506 vn_encode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)pnext);
13507 return;
13508 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
13509 if (!vn_cs_renderer_protocol_has_extension(356 /* VK_EXT_depth_clip_control */))
13510 break;
13511 vn_encode_simple_pointer(enc, pnext);
13512 vn_encode_VkStructureType(enc, &pnext->sType);
13513 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13514 vn_encode_VkPhysicalDeviceDepthClipControlFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)pnext);
13515 return;
13516 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
13517 if (!vn_cs_renderer_protocol_has_extension(353 /* VK_EXT_vertex_input_dynamic_state */))
13518 break;
13519 vn_encode_simple_pointer(enc, pnext);
13520 vn_encode_VkStructureType(enc, &pnext->sType);
13521 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13522 vn_encode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)pnext);
13523 return;
13524 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
13525 if (!vn_cs_renderer_protocol_has_extension(382 /* VK_EXT_color_write_enable */))
13526 break;
13527 vn_encode_simple_pointer(enc, pnext);
13528 vn_encode_VkStructureType(enc, &pnext->sType);
13529 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13530 vn_encode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)pnext);
13531 return;
13532 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
13533 if (!vn_cs_renderer_protocol_has_extension(315 /* VK_KHR_synchronization2 */))
13534 break;
13535 vn_encode_simple_pointer(enc, pnext);
13536 vn_encode_VkStructureType(enc, &pnext->sType);
13537 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13538 vn_encode_VkPhysicalDeviceSynchronization2Features_self_partial(enc, (const VkPhysicalDeviceSynchronization2Features *)pnext);
13539 return;
13540 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
13541 if (!vn_cs_renderer_protocol_has_extension(383 /* VK_EXT_primitives_generated_query */))
13542 break;
13543 vn_encode_simple_pointer(enc, pnext);
13544 vn_encode_VkStructureType(enc, &pnext->sType);
13545 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13546 vn_encode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self_partial(enc, (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)pnext);
13547 return;
13548 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
13549 if (!vn_cs_renderer_protocol_has_extension(331 /* VK_EXT_ycbcr_2plane_444_formats */))
13550 break;
13551 vn_encode_simple_pointer(enc, pnext);
13552 vn_encode_VkStructureType(enc, &pnext->sType);
13553 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13554 vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext);
13555 return;
13556 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
13557 if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
13558 break;
13559 vn_encode_simple_pointer(enc, pnext);
13560 vn_encode_VkStructureType(enc, &pnext->sType);
13561 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13562 vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)pnext);
13563 return;
13564 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
13565 if (!vn_cs_renderer_protocol_has_extension(281 /* VK_KHR_shader_integer_dot_product */))
13566 break;
13567 vn_encode_simple_pointer(enc, pnext);
13568 vn_encode_VkStructureType(enc, &pnext->sType);
13569 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13570 vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial(enc, (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext);
13571 return;
13572 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
13573 if (!vn_cs_renderer_protocol_has_extension(45 /* VK_KHR_dynamic_rendering */))
13574 break;
13575 vn_encode_simple_pointer(enc, pnext);
13576 vn_encode_VkStructureType(enc, &pnext->sType);
13577 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13578 vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self_partial(enc, (const VkPhysicalDeviceDynamicRenderingFeatures *)pnext);
13579 return;
13580 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
13581 if (!vn_cs_renderer_protocol_has_extension(392 /* VK_EXT_image_view_min_lod */))
13582 break;
13583 vn_encode_simple_pointer(enc, pnext);
13584 vn_encode_VkStructureType(enc, &pnext->sType);
13585 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13586 vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)pnext);
13587 return;
13588 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
13589 if (!vn_cs_renderer_protocol_has_extension(464 /* VK_EXT_rasterization_order_attachment_access */))
13590 break;
13591 vn_encode_simple_pointer(enc, pnext);
13592 vn_encode_VkStructureType(enc, &pnext->sType);
13593 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13594 vn_encode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)pnext);
13595 return;
13596 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
13597 if (!vn_cs_renderer_protocol_has_extension(321 /* VK_EXT_graphics_pipeline_library */))
13598 break;
13599 vn_encode_simple_pointer(enc, pnext);
13600 vn_encode_VkStructureType(enc, &pnext->sType);
13601 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13602 vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)pnext);
13603 return;
13604 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
13605 if (!vn_cs_renderer_protocol_has_extension(423 /* VK_EXT_non_seamless_cube_map */))
13606 break;
13607 vn_encode_simple_pointer(enc, pnext);
13608 vn_encode_VkStructureType(enc, &pnext->sType);
13609 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13610 vn_encode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)pnext);
13611 return;
13612 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
13613 if (!vn_cs_renderer_protocol_has_extension(340 /* VK_EXT_attachment_feedback_loop_layout */))
13614 break;
13615 vn_encode_simple_pointer(enc, pnext);
13616 vn_encode_VkStructureType(enc, &pnext->sType);
13617 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13618 vn_encode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)pnext);
13619 return;
13620 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
13621 if (!vn_cs_renderer_protocol_has_extension(500 /* VK_EXT_dynamic_rendering_unused_attachments */))
13622 break;
13623 vn_encode_simple_pointer(enc, pnext);
13624 vn_encode_VkStructureType(enc, &pnext->sType);
13625 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
13626 vn_encode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)pnext);
13627 return;
13628 default:
13629 /* ignore unknown/unsupported struct */
13630 break;
13631 }
13632 pnext = pnext->pNext;
13633 }
13634
13635 vn_encode_simple_pointer(enc, NULL);
13636 }
13637
13638 static inline void
vn_encode_VkPhysicalDeviceFeatures2_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures2 * val)13639 vn_encode_VkPhysicalDeviceFeatures2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
13640 {
13641 /* skip val->{sType,pNext} */
13642 vn_encode_VkPhysicalDeviceFeatures_partial(enc, &val->features);
13643 }
13644
13645 static inline void
vn_encode_VkPhysicalDeviceFeatures2_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures2 * val)13646 vn_encode_VkPhysicalDeviceFeatures2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
13647 {
13648 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
13649 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 });
13650 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, val->pNext);
13651 vn_encode_VkPhysicalDeviceFeatures2_self_partial(enc, val);
13652 }
13653
13654 /* struct VkDeviceGroupDeviceCreateInfo chain */
13655
13656 static inline size_t
vn_sizeof_VkDeviceGroupDeviceCreateInfo_pnext(const void * val)13657 vn_sizeof_VkDeviceGroupDeviceCreateInfo_pnext(const void *val)
13658 {
13659 /* no known/supported struct */
13660 return vn_sizeof_simple_pointer(NULL);
13661 }
13662
13663 static inline size_t
vn_sizeof_VkDeviceGroupDeviceCreateInfo_self(const VkDeviceGroupDeviceCreateInfo * val)13664 vn_sizeof_VkDeviceGroupDeviceCreateInfo_self(const VkDeviceGroupDeviceCreateInfo *val)
13665 {
13666 size_t size = 0;
13667 /* skip val->{sType,pNext} */
13668 size += vn_sizeof_uint32_t(&val->physicalDeviceCount);
13669 if (val->pPhysicalDevices) {
13670 size += vn_sizeof_array_size(val->physicalDeviceCount);
13671 for (uint32_t i = 0; i < val->physicalDeviceCount; i++)
13672 size += vn_sizeof_VkPhysicalDevice(&val->pPhysicalDevices[i]);
13673 } else {
13674 size += vn_sizeof_array_size(0);
13675 }
13676 return size;
13677 }
13678
13679 static inline size_t
vn_sizeof_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo * val)13680 vn_sizeof_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo *val)
13681 {
13682 size_t size = 0;
13683
13684 size += vn_sizeof_VkStructureType(&val->sType);
13685 size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_pnext(val->pNext);
13686 size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_self(val);
13687
13688 return size;
13689 }
13690
13691 static inline void
vn_encode_VkDeviceGroupDeviceCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)13692 vn_encode_VkDeviceGroupDeviceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
13693 {
13694 /* no known/supported struct */
13695 vn_encode_simple_pointer(enc, NULL);
13696 }
13697
13698 static inline void
vn_encode_VkDeviceGroupDeviceCreateInfo_self(struct vn_cs_encoder * enc,const VkDeviceGroupDeviceCreateInfo * val)13699 vn_encode_VkDeviceGroupDeviceCreateInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupDeviceCreateInfo *val)
13700 {
13701 /* skip val->{sType,pNext} */
13702 vn_encode_uint32_t(enc, &val->physicalDeviceCount);
13703 if (val->pPhysicalDevices) {
13704 vn_encode_array_size(enc, val->physicalDeviceCount);
13705 for (uint32_t i = 0; i < val->physicalDeviceCount; i++)
13706 vn_encode_VkPhysicalDevice(enc, &val->pPhysicalDevices[i]);
13707 } else {
13708 vn_encode_array_size(enc, 0);
13709 }
13710 }
13711
13712 static inline void
vn_encode_VkDeviceGroupDeviceCreateInfo(struct vn_cs_encoder * enc,const VkDeviceGroupDeviceCreateInfo * val)13713 vn_encode_VkDeviceGroupDeviceCreateInfo(struct vn_cs_encoder *enc, const VkDeviceGroupDeviceCreateInfo *val)
13714 {
13715 assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO);
13716 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO });
13717 vn_encode_VkDeviceGroupDeviceCreateInfo_pnext(enc, val->pNext);
13718 vn_encode_VkDeviceGroupDeviceCreateInfo_self(enc, val);
13719 }
13720
13721 /* struct VkDeviceCreateInfo chain */
13722
13723 static inline size_t
vn_sizeof_VkDeviceCreateInfo_pnext(const void * val)13724 vn_sizeof_VkDeviceCreateInfo_pnext(const void *val)
13725 {
13726 const VkBaseInStructure *pnext = val;
13727 size_t size = 0;
13728
13729 while (pnext) {
13730 switch ((int32_t)pnext->sType) {
13731 case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
13732 if (!vn_cs_renderer_protocol_has_extension(296 /* VK_EXT_private_data */))
13733 break;
13734 size += vn_sizeof_simple_pointer(pnext);
13735 size += vn_sizeof_VkStructureType(&pnext->sType);
13736 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13737 size += vn_sizeof_VkDevicePrivateDataCreateInfo_self((const VkDevicePrivateDataCreateInfo *)pnext);
13738 return size;
13739 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
13740 if (!vn_cs_renderer_protocol_has_extension(296 /* VK_EXT_private_data */))
13741 break;
13742 size += vn_sizeof_simple_pointer(pnext);
13743 size += vn_sizeof_VkStructureType(&pnext->sType);
13744 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13745 size += vn_sizeof_VkPhysicalDevicePrivateDataFeatures_self((const VkPhysicalDevicePrivateDataFeatures *)pnext);
13746 return size;
13747 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
13748 size += vn_sizeof_simple_pointer(pnext);
13749 size += vn_sizeof_VkStructureType(&pnext->sType);
13750 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13751 size += vn_sizeof_VkPhysicalDeviceFeatures2_self((const VkPhysicalDeviceFeatures2 *)pnext);
13752 return size;
13753 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
13754 size += vn_sizeof_simple_pointer(pnext);
13755 size += vn_sizeof_VkStructureType(&pnext->sType);
13756 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13757 size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self((const VkPhysicalDeviceVariablePointersFeatures *)pnext);
13758 return size;
13759 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
13760 size += vn_sizeof_simple_pointer(pnext);
13761 size += vn_sizeof_VkStructureType(&pnext->sType);
13762 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13763 size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self((const VkPhysicalDeviceMultiviewFeatures *)pnext);
13764 return size;
13765 case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
13766 size += vn_sizeof_simple_pointer(pnext);
13767 size += vn_sizeof_VkStructureType(&pnext->sType);
13768 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13769 size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_self((const VkDeviceGroupDeviceCreateInfo *)pnext);
13770 return size;
13771 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
13772 size += vn_sizeof_simple_pointer(pnext);
13773 size += vn_sizeof_VkStructureType(&pnext->sType);
13774 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13775 size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self((const VkPhysicalDevice16BitStorageFeatures *)pnext);
13776 return size;
13777 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
13778 size += vn_sizeof_simple_pointer(pnext);
13779 size += vn_sizeof_VkStructureType(&pnext->sType);
13780 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13781 size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
13782 return size;
13783 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
13784 size += vn_sizeof_simple_pointer(pnext);
13785 size += vn_sizeof_VkStructureType(&pnext->sType);
13786 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13787 size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
13788 return size;
13789 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
13790 size += vn_sizeof_simple_pointer(pnext);
13791 size += vn_sizeof_VkStructureType(&pnext->sType);
13792 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13793 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
13794 return size;
13795 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
13796 if (!vn_cs_renderer_protocol_has_extension(393 /* VK_EXT_multi_draw */))
13797 break;
13798 size += vn_sizeof_simple_pointer(pnext);
13799 size += vn_sizeof_VkStructureType(&pnext->sType);
13800 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13801 size += vn_sizeof_VkPhysicalDeviceMultiDrawFeaturesEXT_self((const VkPhysicalDeviceMultiDrawFeaturesEXT *)pnext);
13802 return size;
13803 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
13804 if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
13805 break;
13806 size += vn_sizeof_simple_pointer(pnext);
13807 size += vn_sizeof_VkStructureType(&pnext->sType);
13808 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13809 size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self((const VkPhysicalDeviceInlineUniformBlockFeatures *)pnext);
13810 return size;
13811 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
13812 if (!vn_cs_renderer_protocol_has_extension(414 /* VK_KHR_maintenance4 */))
13813 break;
13814 size += vn_sizeof_simple_pointer(pnext);
13815 size += vn_sizeof_VkStructureType(&pnext->sType);
13816 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13817 size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_self((const VkPhysicalDeviceMaintenance4Features *)pnext);
13818 return size;
13819 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
13820 if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
13821 break;
13822 size += vn_sizeof_simple_pointer(pnext);
13823 size += vn_sizeof_VkStructureType(&pnext->sType);
13824 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13825 size += vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_self((const VkPhysicalDeviceMaintenance5FeaturesKHR *)pnext);
13826 return size;
13827 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
13828 size += vn_sizeof_simple_pointer(pnext);
13829 size += vn_sizeof_VkStructureType(&pnext->sType);
13830 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13831 size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
13832 return size;
13833 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
13834 size += vn_sizeof_simple_pointer(pnext);
13835 size += vn_sizeof_VkStructureType(&pnext->sType);
13836 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13837 size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
13838 return size;
13839 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
13840 size += vn_sizeof_simple_pointer(pnext);
13841 size += vn_sizeof_VkStructureType(&pnext->sType);
13842 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13843 size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self((const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
13844 return size;
13845 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
13846 size += vn_sizeof_simple_pointer(pnext);
13847 size += vn_sizeof_VkStructureType(&pnext->sType);
13848 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13849 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
13850 return size;
13851 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
13852 size += vn_sizeof_simple_pointer(pnext);
13853 size += vn_sizeof_VkStructureType(&pnext->sType);
13854 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13855 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
13856 return size;
13857 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
13858 size += vn_sizeof_simple_pointer(pnext);
13859 size += vn_sizeof_VkStructureType(&pnext->sType);
13860 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13861 size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self((const VkPhysicalDevice8BitStorageFeatures *)pnext);
13862 return size;
13863 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
13864 if (!vn_cs_renderer_protocol_has_extension(82 /* VK_EXT_conditional_rendering */))
13865 break;
13866 size += vn_sizeof_simple_pointer(pnext);
13867 size += vn_sizeof_VkStructureType(&pnext->sType);
13868 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13869 size += vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self((const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)pnext);
13870 return size;
13871 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
13872 size += vn_sizeof_simple_pointer(pnext);
13873 size += vn_sizeof_VkStructureType(&pnext->sType);
13874 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13875 size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
13876 return size;
13877 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
13878 size += vn_sizeof_simple_pointer(pnext);
13879 size += vn_sizeof_VkStructureType(&pnext->sType);
13880 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13881 size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
13882 return size;
13883 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
13884 if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
13885 break;
13886 size += vn_sizeof_simple_pointer(pnext);
13887 size += vn_sizeof_VkStructureType(&pnext->sType);
13888 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13889 size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self((const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)pnext);
13890 return size;
13891 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
13892 if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
13893 break;
13894 size += vn_sizeof_simple_pointer(pnext);
13895 size += vn_sizeof_VkStructureType(&pnext->sType);
13896 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13897 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
13898 return size;
13899 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
13900 size += vn_sizeof_simple_pointer(pnext);
13901 size += vn_sizeof_VkStructureType(&pnext->sType);
13902 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13903 size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
13904 return size;
13905 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
13906 size += vn_sizeof_simple_pointer(pnext);
13907 size += vn_sizeof_VkStructureType(&pnext->sType);
13908 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13909 size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
13910 return size;
13911 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
13912 if (!vn_cs_renderer_protocol_has_extension(103 /* VK_EXT_depth_clip_enable */))
13913 break;
13914 size += vn_sizeof_simple_pointer(pnext);
13915 size += vn_sizeof_VkStructureType(&pnext->sType);
13916 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13917 size += vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self((const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)pnext);
13918 return size;
13919 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
13920 size += vn_sizeof_simple_pointer(pnext);
13921 size += vn_sizeof_VkStructureType(&pnext->sType);
13922 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13923 size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
13924 return size;
13925 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
13926 size += vn_sizeof_simple_pointer(pnext);
13927 size += vn_sizeof_VkStructureType(&pnext->sType);
13928 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13929 size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
13930 return size;
13931 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
13932 if (!vn_cs_renderer_protocol_has_extension(67 /* VK_EXT_texture_compression_astc_hdr */))
13933 break;
13934 size += vn_sizeof_simple_pointer(pnext);
13935 size += vn_sizeof_VkStructureType(&pnext->sType);
13936 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13937 size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self((const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext);
13938 return size;
13939 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
13940 if (!vn_cs_renderer_protocol_has_extension(182 /* VK_KHR_shader_clock */))
13941 break;
13942 size += vn_sizeof_simple_pointer(pnext);
13943 size += vn_sizeof_VkStructureType(&pnext->sType);
13944 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13945 size += vn_sizeof_VkPhysicalDeviceShaderClockFeaturesKHR_self((const VkPhysicalDeviceShaderClockFeaturesKHR *)pnext);
13946 return size;
13947 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
13948 if (!vn_cs_renderer_protocol_has_extension(266 /* VK_EXT_index_type_uint8 */))
13949 break;
13950 size += vn_sizeof_simple_pointer(pnext);
13951 size += vn_sizeof_VkStructureType(&pnext->sType);
13952 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13953 size += vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self((const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)pnext);
13954 return size;
13955 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
13956 if (!vn_cs_renderer_protocol_has_extension(252 /* VK_EXT_fragment_shader_interlock */))
13957 break;
13958 size += vn_sizeof_simple_pointer(pnext);
13959 size += vn_sizeof_VkStructureType(&pnext->sType);
13960 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13961 size += vn_sizeof_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self((const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)pnext);
13962 return size;
13963 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
13964 size += vn_sizeof_simple_pointer(pnext);
13965 size += vn_sizeof_VkStructureType(&pnext->sType);
13966 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13967 size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
13968 return size;
13969 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
13970 if (!vn_cs_renderer_protocol_has_extension(357 /* VK_EXT_primitive_topology_list_restart */))
13971 break;
13972 size += vn_sizeof_simple_pointer(pnext);
13973 size += vn_sizeof_VkStructureType(&pnext->sType);
13974 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13975 size += vn_sizeof_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self((const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)pnext);
13976 return size;
13977 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
13978 if (!vn_cs_renderer_protocol_has_extension(277 /* VK_EXT_shader_demote_to_helper_invocation */))
13979 break;
13980 size += vn_sizeof_simple_pointer(pnext);
13981 size += vn_sizeof_VkStructureType(&pnext->sType);
13982 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13983 size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self((const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext);
13984 return size;
13985 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
13986 if (!vn_cs_renderer_protocol_has_extension(282 /* VK_EXT_texel_buffer_alignment */))
13987 break;
13988 size += vn_sizeof_simple_pointer(pnext);
13989 size += vn_sizeof_VkStructureType(&pnext->sType);
13990 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13991 size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self((const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext);
13992 return size;
13993 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
13994 if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
13995 break;
13996 size += vn_sizeof_simple_pointer(pnext);
13997 size += vn_sizeof_VkStructureType(&pnext->sType);
13998 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
13999 size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self((const VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext);
14000 return size;
14001 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
14002 if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
14003 break;
14004 size += vn_sizeof_simple_pointer(pnext);
14005 size += vn_sizeof_VkStructureType(&pnext->sType);
14006 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14007 size += vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_self((const VkPhysicalDeviceLineRasterizationFeaturesEXT *)pnext);
14008 return size;
14009 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
14010 if (!vn_cs_renderer_protocol_has_extension(298 /* VK_EXT_pipeline_creation_cache_control */))
14011 break;
14012 size += vn_sizeof_simple_pointer(pnext);
14013 size += vn_sizeof_VkStructureType(&pnext->sType);
14014 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14015 size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self((const VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext);
14016 return size;
14017 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
14018 size += vn_sizeof_simple_pointer(pnext);
14019 size += vn_sizeof_VkStructureType(&pnext->sType);
14020 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14021 size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self((const VkPhysicalDeviceVulkan11Features *)pnext);
14022 return size;
14023 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
14024 size += vn_sizeof_simple_pointer(pnext);
14025 size += vn_sizeof_VkStructureType(&pnext->sType);
14026 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14027 size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self((const VkPhysicalDeviceVulkan12Features *)pnext);
14028 return size;
14029 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
14030 if (!vn_cs_renderer_protocol_has_api_version(VK_API_VERSION_1_3))
14031 break;
14032 size += vn_sizeof_simple_pointer(pnext);
14033 size += vn_sizeof_VkStructureType(&pnext->sType);
14034 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14035 size += vn_sizeof_VkPhysicalDeviceVulkan13Features_self((const VkPhysicalDeviceVulkan13Features *)pnext);
14036 return size;
14037 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
14038 if (!vn_cs_renderer_protocol_has_extension(288 /* VK_EXT_custom_border_color */))
14039 break;
14040 size += vn_sizeof_simple_pointer(pnext);
14041 size += vn_sizeof_VkStructureType(&pnext->sType);
14042 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14043 size += vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self((const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)pnext);
14044 return size;
14045 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
14046 if (!vn_cs_renderer_protocol_has_extension(412 /* VK_EXT_border_color_swizzle */))
14047 break;
14048 size += vn_sizeof_simple_pointer(pnext);
14049 size += vn_sizeof_VkStructureType(&pnext->sType);
14050 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14051 size += vn_sizeof_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self((const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)pnext);
14052 return size;
14053 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
14054 if (!vn_cs_renderer_protocol_has_extension(268 /* VK_EXT_extended_dynamic_state */))
14055 break;
14056 size += vn_sizeof_simple_pointer(pnext);
14057 size += vn_sizeof_VkStructureType(&pnext->sType);
14058 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14059 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self((const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext);
14060 return size;
14061 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
14062 if (!vn_cs_renderer_protocol_has_extension(378 /* VK_EXT_extended_dynamic_state2 */))
14063 break;
14064 size += vn_sizeof_simple_pointer(pnext);
14065 size += vn_sizeof_VkStructureType(&pnext->sType);
14066 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14067 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self((const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext);
14068 return size;
14069 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
14070 if (!vn_cs_renderer_protocol_has_extension(456 /* VK_EXT_extended_dynamic_state3 */))
14071 break;
14072 size += vn_sizeof_simple_pointer(pnext);
14073 size += vn_sizeof_VkStructureType(&pnext->sType);
14074 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14075 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self((const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)pnext);
14076 return size;
14077 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
14078 if (!vn_cs_renderer_protocol_has_extension(326 /* VK_KHR_zero_initialize_workgroup_memory */))
14079 break;
14080 size += vn_sizeof_simple_pointer(pnext);
14081 size += vn_sizeof_VkStructureType(&pnext->sType);
14082 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14083 size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self((const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext);
14084 return size;
14085 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
14086 if (!vn_cs_renderer_protocol_has_extension(287 /* VK_EXT_robustness2 */))
14087 break;
14088 size += vn_sizeof_simple_pointer(pnext);
14089 size += vn_sizeof_VkStructureType(&pnext->sType);
14090 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14091 size += vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_self((const VkPhysicalDeviceRobustness2FeaturesEXT *)pnext);
14092 return size;
14093 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
14094 if (!vn_cs_renderer_protocol_has_extension(336 /* VK_EXT_image_robustness */))
14095 break;
14096 size += vn_sizeof_simple_pointer(pnext);
14097 size += vn_sizeof_VkStructureType(&pnext->sType);
14098 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14099 size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self((const VkPhysicalDeviceImageRobustnessFeatures *)pnext);
14100 return size;
14101 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
14102 if (!vn_cs_renderer_protocol_has_extension(341 /* VK_EXT_4444_formats */))
14103 break;
14104 size += vn_sizeof_simple_pointer(pnext);
14105 size += vn_sizeof_VkStructureType(&pnext->sType);
14106 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14107 size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self((const VkPhysicalDevice4444FormatsFeaturesEXT *)pnext);
14108 return size;
14109 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
14110 if (!vn_cs_renderer_protocol_has_extension(227 /* VK_KHR_fragment_shading_rate */))
14111 break;
14112 size += vn_sizeof_simple_pointer(pnext);
14113 size += vn_sizeof_VkStructureType(&pnext->sType);
14114 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14115 size += vn_sizeof_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self((const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)pnext);
14116 return size;
14117 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
14118 if (!vn_cs_renderer_protocol_has_extension(216 /* VK_KHR_shader_terminate_invocation */))
14119 break;
14120 size += vn_sizeof_simple_pointer(pnext);
14121 size += vn_sizeof_VkStructureType(&pnext->sType);
14122 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14123 size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self((const VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext);
14124 return size;
14125 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
14126 if (!vn_cs_renderer_protocol_has_extension(394 /* VK_EXT_image_2d_view_of_3d */))
14127 break;
14128 size += vn_sizeof_simple_pointer(pnext);
14129 size += vn_sizeof_VkStructureType(&pnext->sType);
14130 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14131 size += vn_sizeof_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self((const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)pnext);
14132 return size;
14133 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
14134 if (!vn_cs_renderer_protocol_has_extension(352 /* VK_VALVE_mutable_descriptor_type */) && !vn_cs_renderer_protocol_has_extension(495 /* VK_EXT_mutable_descriptor_type */))
14135 break;
14136 size += vn_sizeof_simple_pointer(pnext);
14137 size += vn_sizeof_VkStructureType(&pnext->sType);
14138 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14139 size += vn_sizeof_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self((const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)pnext);
14140 return size;
14141 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
14142 if (!vn_cs_renderer_protocol_has_extension(356 /* VK_EXT_depth_clip_control */))
14143 break;
14144 size += vn_sizeof_simple_pointer(pnext);
14145 size += vn_sizeof_VkStructureType(&pnext->sType);
14146 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14147 size += vn_sizeof_VkPhysicalDeviceDepthClipControlFeaturesEXT_self((const VkPhysicalDeviceDepthClipControlFeaturesEXT *)pnext);
14148 return size;
14149 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
14150 if (!vn_cs_renderer_protocol_has_extension(353 /* VK_EXT_vertex_input_dynamic_state */))
14151 break;
14152 size += vn_sizeof_simple_pointer(pnext);
14153 size += vn_sizeof_VkStructureType(&pnext->sType);
14154 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14155 size += vn_sizeof_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self((const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)pnext);
14156 return size;
14157 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
14158 if (!vn_cs_renderer_protocol_has_extension(382 /* VK_EXT_color_write_enable */))
14159 break;
14160 size += vn_sizeof_simple_pointer(pnext);
14161 size += vn_sizeof_VkStructureType(&pnext->sType);
14162 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14163 size += vn_sizeof_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self((const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)pnext);
14164 return size;
14165 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
14166 if (!vn_cs_renderer_protocol_has_extension(315 /* VK_KHR_synchronization2 */))
14167 break;
14168 size += vn_sizeof_simple_pointer(pnext);
14169 size += vn_sizeof_VkStructureType(&pnext->sType);
14170 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14171 size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_self((const VkPhysicalDeviceSynchronization2Features *)pnext);
14172 return size;
14173 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
14174 if (!vn_cs_renderer_protocol_has_extension(383 /* VK_EXT_primitives_generated_query */))
14175 break;
14176 size += vn_sizeof_simple_pointer(pnext);
14177 size += vn_sizeof_VkStructureType(&pnext->sType);
14178 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14179 size += vn_sizeof_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self((const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)pnext);
14180 return size;
14181 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
14182 if (!vn_cs_renderer_protocol_has_extension(331 /* VK_EXT_ycbcr_2plane_444_formats */))
14183 break;
14184 size += vn_sizeof_simple_pointer(pnext);
14185 size += vn_sizeof_VkStructureType(&pnext->sType);
14186 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14187 size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self((const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext);
14188 return size;
14189 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
14190 if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
14191 break;
14192 size += vn_sizeof_simple_pointer(pnext);
14193 size += vn_sizeof_VkStructureType(&pnext->sType);
14194 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14195 size += vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_self((const VkPhysicalDeviceProvokingVertexFeaturesEXT *)pnext);
14196 return size;
14197 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
14198 if (!vn_cs_renderer_protocol_has_extension(281 /* VK_KHR_shader_integer_dot_product */))
14199 break;
14200 size += vn_sizeof_simple_pointer(pnext);
14201 size += vn_sizeof_VkStructureType(&pnext->sType);
14202 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14203 size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self((const VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext);
14204 return size;
14205 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
14206 if (!vn_cs_renderer_protocol_has_extension(45 /* VK_KHR_dynamic_rendering */))
14207 break;
14208 size += vn_sizeof_simple_pointer(pnext);
14209 size += vn_sizeof_VkStructureType(&pnext->sType);
14210 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14211 size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self((const VkPhysicalDeviceDynamicRenderingFeatures *)pnext);
14212 return size;
14213 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
14214 if (!vn_cs_renderer_protocol_has_extension(392 /* VK_EXT_image_view_min_lod */))
14215 break;
14216 size += vn_sizeof_simple_pointer(pnext);
14217 size += vn_sizeof_VkStructureType(&pnext->sType);
14218 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14219 size += vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self((const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)pnext);
14220 return size;
14221 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
14222 if (!vn_cs_renderer_protocol_has_extension(464 /* VK_EXT_rasterization_order_attachment_access */))
14223 break;
14224 size += vn_sizeof_simple_pointer(pnext);
14225 size += vn_sizeof_VkStructureType(&pnext->sType);
14226 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14227 size += vn_sizeof_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self((const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)pnext);
14228 return size;
14229 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
14230 if (!vn_cs_renderer_protocol_has_extension(321 /* VK_EXT_graphics_pipeline_library */))
14231 break;
14232 size += vn_sizeof_simple_pointer(pnext);
14233 size += vn_sizeof_VkStructureType(&pnext->sType);
14234 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14235 size += vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self((const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)pnext);
14236 return size;
14237 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
14238 if (!vn_cs_renderer_protocol_has_extension(423 /* VK_EXT_non_seamless_cube_map */))
14239 break;
14240 size += vn_sizeof_simple_pointer(pnext);
14241 size += vn_sizeof_VkStructureType(&pnext->sType);
14242 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14243 size += vn_sizeof_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self((const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)pnext);
14244 return size;
14245 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
14246 if (!vn_cs_renderer_protocol_has_extension(340 /* VK_EXT_attachment_feedback_loop_layout */))
14247 break;
14248 size += vn_sizeof_simple_pointer(pnext);
14249 size += vn_sizeof_VkStructureType(&pnext->sType);
14250 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14251 size += vn_sizeof_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self((const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)pnext);
14252 return size;
14253 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
14254 if (!vn_cs_renderer_protocol_has_extension(500 /* VK_EXT_dynamic_rendering_unused_attachments */))
14255 break;
14256 size += vn_sizeof_simple_pointer(pnext);
14257 size += vn_sizeof_VkStructureType(&pnext->sType);
14258 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
14259 size += vn_sizeof_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self((const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)pnext);
14260 return size;
14261 default:
14262 /* ignore unknown/unsupported struct */
14263 break;
14264 }
14265 pnext = pnext->pNext;
14266 }
14267
14268 return vn_sizeof_simple_pointer(NULL);
14269 }
14270
14271 static inline size_t
vn_sizeof_VkDeviceCreateInfo_self(const VkDeviceCreateInfo * val)14272 vn_sizeof_VkDeviceCreateInfo_self(const VkDeviceCreateInfo *val)
14273 {
14274 size_t size = 0;
14275 /* skip val->{sType,pNext} */
14276 size += vn_sizeof_VkFlags(&val->flags);
14277 size += vn_sizeof_uint32_t(&val->queueCreateInfoCount);
14278 if (val->pQueueCreateInfos) {
14279 size += vn_sizeof_array_size(val->queueCreateInfoCount);
14280 for (uint32_t i = 0; i < val->queueCreateInfoCount; i++)
14281 size += vn_sizeof_VkDeviceQueueCreateInfo(&val->pQueueCreateInfos[i]);
14282 } else {
14283 size += vn_sizeof_array_size(0);
14284 }
14285 size += vn_sizeof_uint32_t(&val->enabledLayerCount);
14286 if (val->ppEnabledLayerNames) {
14287 size += vn_sizeof_array_size(val->enabledLayerCount);
14288 for (uint32_t i = 0; i < val->enabledLayerCount; i++) {
14289 const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1;
14290 size += vn_sizeof_array_size(string_size);
14291 size += vn_sizeof_char_array(val->ppEnabledLayerNames[i], string_size);
14292 }
14293 } else {
14294 size += vn_sizeof_array_size(0);
14295 }
14296 size += vn_sizeof_uint32_t(&val->enabledExtensionCount);
14297 if (val->ppEnabledExtensionNames) {
14298 size += vn_sizeof_array_size(val->enabledExtensionCount);
14299 for (uint32_t i = 0; i < val->enabledExtensionCount; i++) {
14300 const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1;
14301 size += vn_sizeof_array_size(string_size);
14302 size += vn_sizeof_char_array(val->ppEnabledExtensionNames[i], string_size);
14303 }
14304 } else {
14305 size += vn_sizeof_array_size(0);
14306 }
14307 size += vn_sizeof_simple_pointer(val->pEnabledFeatures);
14308 if (val->pEnabledFeatures)
14309 size += vn_sizeof_VkPhysicalDeviceFeatures(val->pEnabledFeatures);
14310 return size;
14311 }
14312
14313 static inline size_t
vn_sizeof_VkDeviceCreateInfo(const VkDeviceCreateInfo * val)14314 vn_sizeof_VkDeviceCreateInfo(const VkDeviceCreateInfo *val)
14315 {
14316 size_t size = 0;
14317
14318 size += vn_sizeof_VkStructureType(&val->sType);
14319 size += vn_sizeof_VkDeviceCreateInfo_pnext(val->pNext);
14320 size += vn_sizeof_VkDeviceCreateInfo_self(val);
14321
14322 return size;
14323 }
14324
14325 static inline void
vn_encode_VkDeviceCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)14326 vn_encode_VkDeviceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
14327 {
14328 const VkBaseInStructure *pnext = val;
14329
14330 while (pnext) {
14331 switch ((int32_t)pnext->sType) {
14332 case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
14333 if (!vn_cs_renderer_protocol_has_extension(296 /* VK_EXT_private_data */))
14334 break;
14335 vn_encode_simple_pointer(enc, pnext);
14336 vn_encode_VkStructureType(enc, &pnext->sType);
14337 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14338 vn_encode_VkDevicePrivateDataCreateInfo_self(enc, (const VkDevicePrivateDataCreateInfo *)pnext);
14339 return;
14340 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
14341 if (!vn_cs_renderer_protocol_has_extension(296 /* VK_EXT_private_data */))
14342 break;
14343 vn_encode_simple_pointer(enc, pnext);
14344 vn_encode_VkStructureType(enc, &pnext->sType);
14345 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14346 vn_encode_VkPhysicalDevicePrivateDataFeatures_self(enc, (const VkPhysicalDevicePrivateDataFeatures *)pnext);
14347 return;
14348 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
14349 vn_encode_simple_pointer(enc, pnext);
14350 vn_encode_VkStructureType(enc, &pnext->sType);
14351 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14352 vn_encode_VkPhysicalDeviceFeatures2_self(enc, (const VkPhysicalDeviceFeatures2 *)pnext);
14353 return;
14354 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
14355 vn_encode_simple_pointer(enc, pnext);
14356 vn_encode_VkStructureType(enc, &pnext->sType);
14357 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14358 vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext);
14359 return;
14360 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
14361 vn_encode_simple_pointer(enc, pnext);
14362 vn_encode_VkStructureType(enc, &pnext->sType);
14363 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14364 vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext);
14365 return;
14366 case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
14367 vn_encode_simple_pointer(enc, pnext);
14368 vn_encode_VkStructureType(enc, &pnext->sType);
14369 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14370 vn_encode_VkDeviceGroupDeviceCreateInfo_self(enc, (const VkDeviceGroupDeviceCreateInfo *)pnext);
14371 return;
14372 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
14373 vn_encode_simple_pointer(enc, pnext);
14374 vn_encode_VkStructureType(enc, &pnext->sType);
14375 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14376 vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext);
14377 return;
14378 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
14379 vn_encode_simple_pointer(enc, pnext);
14380 vn_encode_VkStructureType(enc, &pnext->sType);
14381 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14382 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
14383 return;
14384 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
14385 vn_encode_simple_pointer(enc, pnext);
14386 vn_encode_VkStructureType(enc, &pnext->sType);
14387 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14388 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
14389 return;
14390 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
14391 vn_encode_simple_pointer(enc, pnext);
14392 vn_encode_VkStructureType(enc, &pnext->sType);
14393 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14394 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
14395 return;
14396 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
14397 if (!vn_cs_renderer_protocol_has_extension(393 /* VK_EXT_multi_draw */))
14398 break;
14399 vn_encode_simple_pointer(enc, pnext);
14400 vn_encode_VkStructureType(enc, &pnext->sType);
14401 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14402 vn_encode_VkPhysicalDeviceMultiDrawFeaturesEXT_self(enc, (const VkPhysicalDeviceMultiDrawFeaturesEXT *)pnext);
14403 return;
14404 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
14405 if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
14406 break;
14407 vn_encode_simple_pointer(enc, pnext);
14408 vn_encode_VkStructureType(enc, &pnext->sType);
14409 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14410 vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self(enc, (const VkPhysicalDeviceInlineUniformBlockFeatures *)pnext);
14411 return;
14412 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
14413 if (!vn_cs_renderer_protocol_has_extension(414 /* VK_KHR_maintenance4 */))
14414 break;
14415 vn_encode_simple_pointer(enc, pnext);
14416 vn_encode_VkStructureType(enc, &pnext->sType);
14417 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14418 vn_encode_VkPhysicalDeviceMaintenance4Features_self(enc, (const VkPhysicalDeviceMaintenance4Features *)pnext);
14419 return;
14420 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
14421 if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
14422 break;
14423 vn_encode_simple_pointer(enc, pnext);
14424 vn_encode_VkStructureType(enc, &pnext->sType);
14425 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14426 vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_self(enc, (const VkPhysicalDeviceMaintenance5FeaturesKHR *)pnext);
14427 return;
14428 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
14429 vn_encode_simple_pointer(enc, pnext);
14430 vn_encode_VkStructureType(enc, &pnext->sType);
14431 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14432 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
14433 return;
14434 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
14435 vn_encode_simple_pointer(enc, pnext);
14436 vn_encode_VkStructureType(enc, &pnext->sType);
14437 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14438 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
14439 return;
14440 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
14441 vn_encode_simple_pointer(enc, pnext);
14442 vn_encode_VkStructureType(enc, &pnext->sType);
14443 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14444 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
14445 return;
14446 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
14447 vn_encode_simple_pointer(enc, pnext);
14448 vn_encode_VkStructureType(enc, &pnext->sType);
14449 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14450 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
14451 return;
14452 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
14453 vn_encode_simple_pointer(enc, pnext);
14454 vn_encode_VkStructureType(enc, &pnext->sType);
14455 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14456 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
14457 return;
14458 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
14459 vn_encode_simple_pointer(enc, pnext);
14460 vn_encode_VkStructureType(enc, &pnext->sType);
14461 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14462 vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext);
14463 return;
14464 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
14465 if (!vn_cs_renderer_protocol_has_extension(82 /* VK_EXT_conditional_rendering */))
14466 break;
14467 vn_encode_simple_pointer(enc, pnext);
14468 vn_encode_VkStructureType(enc, &pnext->sType);
14469 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14470 vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(enc, (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)pnext);
14471 return;
14472 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
14473 vn_encode_simple_pointer(enc, pnext);
14474 vn_encode_VkStructureType(enc, &pnext->sType);
14475 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14476 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
14477 return;
14478 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
14479 vn_encode_simple_pointer(enc, pnext);
14480 vn_encode_VkStructureType(enc, &pnext->sType);
14481 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14482 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
14483 return;
14484 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
14485 if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
14486 break;
14487 vn_encode_simple_pointer(enc, pnext);
14488 vn_encode_VkStructureType(enc, &pnext->sType);
14489 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14490 vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(enc, (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)pnext);
14491 return;
14492 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
14493 if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
14494 break;
14495 vn_encode_simple_pointer(enc, pnext);
14496 vn_encode_VkStructureType(enc, &pnext->sType);
14497 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14498 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
14499 return;
14500 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
14501 vn_encode_simple_pointer(enc, pnext);
14502 vn_encode_VkStructureType(enc, &pnext->sType);
14503 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14504 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
14505 return;
14506 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
14507 vn_encode_simple_pointer(enc, pnext);
14508 vn_encode_VkStructureType(enc, &pnext->sType);
14509 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14510 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
14511 return;
14512 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
14513 if (!vn_cs_renderer_protocol_has_extension(103 /* VK_EXT_depth_clip_enable */))
14514 break;
14515 vn_encode_simple_pointer(enc, pnext);
14516 vn_encode_VkStructureType(enc, &pnext->sType);
14517 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14518 vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(enc, (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)pnext);
14519 return;
14520 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
14521 vn_encode_simple_pointer(enc, pnext);
14522 vn_encode_VkStructureType(enc, &pnext->sType);
14523 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14524 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
14525 return;
14526 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
14527 vn_encode_simple_pointer(enc, pnext);
14528 vn_encode_VkStructureType(enc, &pnext->sType);
14529 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14530 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
14531 return;
14532 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
14533 if (!vn_cs_renderer_protocol_has_extension(67 /* VK_EXT_texture_compression_astc_hdr */))
14534 break;
14535 vn_encode_simple_pointer(enc, pnext);
14536 vn_encode_VkStructureType(enc, &pnext->sType);
14537 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14538 vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(enc, (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext);
14539 return;
14540 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
14541 if (!vn_cs_renderer_protocol_has_extension(182 /* VK_KHR_shader_clock */))
14542 break;
14543 vn_encode_simple_pointer(enc, pnext);
14544 vn_encode_VkStructureType(enc, &pnext->sType);
14545 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14546 vn_encode_VkPhysicalDeviceShaderClockFeaturesKHR_self(enc, (const VkPhysicalDeviceShaderClockFeaturesKHR *)pnext);
14547 return;
14548 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
14549 if (!vn_cs_renderer_protocol_has_extension(266 /* VK_EXT_index_type_uint8 */))
14550 break;
14551 vn_encode_simple_pointer(enc, pnext);
14552 vn_encode_VkStructureType(enc, &pnext->sType);
14553 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14554 vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(enc, (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)pnext);
14555 return;
14556 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
14557 if (!vn_cs_renderer_protocol_has_extension(252 /* VK_EXT_fragment_shader_interlock */))
14558 break;
14559 vn_encode_simple_pointer(enc, pnext);
14560 vn_encode_VkStructureType(enc, &pnext->sType);
14561 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14562 vn_encode_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT_self(enc, (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)pnext);
14563 return;
14564 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
14565 vn_encode_simple_pointer(enc, pnext);
14566 vn_encode_VkStructureType(enc, &pnext->sType);
14567 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14568 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
14569 return;
14570 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
14571 if (!vn_cs_renderer_protocol_has_extension(357 /* VK_EXT_primitive_topology_list_restart */))
14572 break;
14573 vn_encode_simple_pointer(enc, pnext);
14574 vn_encode_VkStructureType(enc, &pnext->sType);
14575 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14576 vn_encode_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT_self(enc, (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)pnext);
14577 return;
14578 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
14579 if (!vn_cs_renderer_protocol_has_extension(277 /* VK_EXT_shader_demote_to_helper_invocation */))
14580 break;
14581 vn_encode_simple_pointer(enc, pnext);
14582 vn_encode_VkStructureType(enc, &pnext->sType);
14583 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14584 vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(enc, (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext);
14585 return;
14586 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
14587 if (!vn_cs_renderer_protocol_has_extension(282 /* VK_EXT_texel_buffer_alignment */))
14588 break;
14589 vn_encode_simple_pointer(enc, pnext);
14590 vn_encode_VkStructureType(enc, &pnext->sType);
14591 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14592 vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(enc, (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext);
14593 return;
14594 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
14595 if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
14596 break;
14597 vn_encode_simple_pointer(enc, pnext);
14598 vn_encode_VkStructureType(enc, &pnext->sType);
14599 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14600 vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(enc, (const VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext);
14601 return;
14602 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
14603 if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
14604 break;
14605 vn_encode_simple_pointer(enc, pnext);
14606 vn_encode_VkStructureType(enc, &pnext->sType);
14607 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14608 vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(enc, (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)pnext);
14609 return;
14610 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
14611 if (!vn_cs_renderer_protocol_has_extension(298 /* VK_EXT_pipeline_creation_cache_control */))
14612 break;
14613 vn_encode_simple_pointer(enc, pnext);
14614 vn_encode_VkStructureType(enc, &pnext->sType);
14615 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14616 vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(enc, (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext);
14617 return;
14618 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
14619 vn_encode_simple_pointer(enc, pnext);
14620 vn_encode_VkStructureType(enc, &pnext->sType);
14621 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14622 vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, (const VkPhysicalDeviceVulkan11Features *)pnext);
14623 return;
14624 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
14625 vn_encode_simple_pointer(enc, pnext);
14626 vn_encode_VkStructureType(enc, &pnext->sType);
14627 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14628 vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, (const VkPhysicalDeviceVulkan12Features *)pnext);
14629 return;
14630 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
14631 if (!vn_cs_renderer_protocol_has_api_version(VK_API_VERSION_1_3))
14632 break;
14633 vn_encode_simple_pointer(enc, pnext);
14634 vn_encode_VkStructureType(enc, &pnext->sType);
14635 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14636 vn_encode_VkPhysicalDeviceVulkan13Features_self(enc, (const VkPhysicalDeviceVulkan13Features *)pnext);
14637 return;
14638 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
14639 if (!vn_cs_renderer_protocol_has_extension(288 /* VK_EXT_custom_border_color */))
14640 break;
14641 vn_encode_simple_pointer(enc, pnext);
14642 vn_encode_VkStructureType(enc, &pnext->sType);
14643 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14644 vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(enc, (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)pnext);
14645 return;
14646 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
14647 if (!vn_cs_renderer_protocol_has_extension(412 /* VK_EXT_border_color_swizzle */))
14648 break;
14649 vn_encode_simple_pointer(enc, pnext);
14650 vn_encode_VkStructureType(enc, &pnext->sType);
14651 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14652 vn_encode_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT_self(enc, (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)pnext);
14653 return;
14654 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
14655 if (!vn_cs_renderer_protocol_has_extension(268 /* VK_EXT_extended_dynamic_state */))
14656 break;
14657 vn_encode_simple_pointer(enc, pnext);
14658 vn_encode_VkStructureType(enc, &pnext->sType);
14659 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14660 vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(enc, (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext);
14661 return;
14662 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
14663 if (!vn_cs_renderer_protocol_has_extension(378 /* VK_EXT_extended_dynamic_state2 */))
14664 break;
14665 vn_encode_simple_pointer(enc, pnext);
14666 vn_encode_VkStructureType(enc, &pnext->sType);
14667 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14668 vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(enc, (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext);
14669 return;
14670 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
14671 if (!vn_cs_renderer_protocol_has_extension(456 /* VK_EXT_extended_dynamic_state3 */))
14672 break;
14673 vn_encode_simple_pointer(enc, pnext);
14674 vn_encode_VkStructureType(enc, &pnext->sType);
14675 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14676 vn_encode_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT_self(enc, (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)pnext);
14677 return;
14678 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
14679 if (!vn_cs_renderer_protocol_has_extension(326 /* VK_KHR_zero_initialize_workgroup_memory */))
14680 break;
14681 vn_encode_simple_pointer(enc, pnext);
14682 vn_encode_VkStructureType(enc, &pnext->sType);
14683 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14684 vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(enc, (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext);
14685 return;
14686 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
14687 if (!vn_cs_renderer_protocol_has_extension(287 /* VK_EXT_robustness2 */))
14688 break;
14689 vn_encode_simple_pointer(enc, pnext);
14690 vn_encode_VkStructureType(enc, &pnext->sType);
14691 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14692 vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_self(enc, (const VkPhysicalDeviceRobustness2FeaturesEXT *)pnext);
14693 return;
14694 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
14695 if (!vn_cs_renderer_protocol_has_extension(336 /* VK_EXT_image_robustness */))
14696 break;
14697 vn_encode_simple_pointer(enc, pnext);
14698 vn_encode_VkStructureType(enc, &pnext->sType);
14699 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14700 vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self(enc, (const VkPhysicalDeviceImageRobustnessFeatures *)pnext);
14701 return;
14702 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
14703 if (!vn_cs_renderer_protocol_has_extension(341 /* VK_EXT_4444_formats */))
14704 break;
14705 vn_encode_simple_pointer(enc, pnext);
14706 vn_encode_VkStructureType(enc, &pnext->sType);
14707 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14708 vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self(enc, (const VkPhysicalDevice4444FormatsFeaturesEXT *)pnext);
14709 return;
14710 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
14711 if (!vn_cs_renderer_protocol_has_extension(227 /* VK_KHR_fragment_shading_rate */))
14712 break;
14713 vn_encode_simple_pointer(enc, pnext);
14714 vn_encode_VkStructureType(enc, &pnext->sType);
14715 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14716 vn_encode_VkPhysicalDeviceFragmentShadingRateFeaturesKHR_self(enc, (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)pnext);
14717 return;
14718 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
14719 if (!vn_cs_renderer_protocol_has_extension(216 /* VK_KHR_shader_terminate_invocation */))
14720 break;
14721 vn_encode_simple_pointer(enc, pnext);
14722 vn_encode_VkStructureType(enc, &pnext->sType);
14723 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14724 vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(enc, (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext);
14725 return;
14726 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
14727 if (!vn_cs_renderer_protocol_has_extension(394 /* VK_EXT_image_2d_view_of_3d */))
14728 break;
14729 vn_encode_simple_pointer(enc, pnext);
14730 vn_encode_VkStructureType(enc, &pnext->sType);
14731 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14732 vn_encode_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT_self(enc, (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)pnext);
14733 return;
14734 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
14735 if (!vn_cs_renderer_protocol_has_extension(352 /* VK_VALVE_mutable_descriptor_type */) && !vn_cs_renderer_protocol_has_extension(495 /* VK_EXT_mutable_descriptor_type */))
14736 break;
14737 vn_encode_simple_pointer(enc, pnext);
14738 vn_encode_VkStructureType(enc, &pnext->sType);
14739 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14740 vn_encode_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT_self(enc, (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)pnext);
14741 return;
14742 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
14743 if (!vn_cs_renderer_protocol_has_extension(356 /* VK_EXT_depth_clip_control */))
14744 break;
14745 vn_encode_simple_pointer(enc, pnext);
14746 vn_encode_VkStructureType(enc, &pnext->sType);
14747 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14748 vn_encode_VkPhysicalDeviceDepthClipControlFeaturesEXT_self(enc, (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)pnext);
14749 return;
14750 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
14751 if (!vn_cs_renderer_protocol_has_extension(353 /* VK_EXT_vertex_input_dynamic_state */))
14752 break;
14753 vn_encode_simple_pointer(enc, pnext);
14754 vn_encode_VkStructureType(enc, &pnext->sType);
14755 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14756 vn_encode_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT_self(enc, (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)pnext);
14757 return;
14758 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
14759 if (!vn_cs_renderer_protocol_has_extension(382 /* VK_EXT_color_write_enable */))
14760 break;
14761 vn_encode_simple_pointer(enc, pnext);
14762 vn_encode_VkStructureType(enc, &pnext->sType);
14763 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14764 vn_encode_VkPhysicalDeviceColorWriteEnableFeaturesEXT_self(enc, (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)pnext);
14765 return;
14766 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
14767 if (!vn_cs_renderer_protocol_has_extension(315 /* VK_KHR_synchronization2 */))
14768 break;
14769 vn_encode_simple_pointer(enc, pnext);
14770 vn_encode_VkStructureType(enc, &pnext->sType);
14771 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14772 vn_encode_VkPhysicalDeviceSynchronization2Features_self(enc, (const VkPhysicalDeviceSynchronization2Features *)pnext);
14773 return;
14774 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
14775 if (!vn_cs_renderer_protocol_has_extension(383 /* VK_EXT_primitives_generated_query */))
14776 break;
14777 vn_encode_simple_pointer(enc, pnext);
14778 vn_encode_VkStructureType(enc, &pnext->sType);
14779 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14780 vn_encode_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT_self(enc, (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)pnext);
14781 return;
14782 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
14783 if (!vn_cs_renderer_protocol_has_extension(331 /* VK_EXT_ycbcr_2plane_444_formats */))
14784 break;
14785 vn_encode_simple_pointer(enc, pnext);
14786 vn_encode_VkStructureType(enc, &pnext->sType);
14787 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14788 vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(enc, (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext);
14789 return;
14790 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
14791 if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
14792 break;
14793 vn_encode_simple_pointer(enc, pnext);
14794 vn_encode_VkStructureType(enc, &pnext->sType);
14795 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14796 vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(enc, (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)pnext);
14797 return;
14798 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
14799 if (!vn_cs_renderer_protocol_has_extension(281 /* VK_KHR_shader_integer_dot_product */))
14800 break;
14801 vn_encode_simple_pointer(enc, pnext);
14802 vn_encode_VkStructureType(enc, &pnext->sType);
14803 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14804 vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(enc, (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext);
14805 return;
14806 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
14807 if (!vn_cs_renderer_protocol_has_extension(45 /* VK_KHR_dynamic_rendering */))
14808 break;
14809 vn_encode_simple_pointer(enc, pnext);
14810 vn_encode_VkStructureType(enc, &pnext->sType);
14811 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14812 vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self(enc, (const VkPhysicalDeviceDynamicRenderingFeatures *)pnext);
14813 return;
14814 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
14815 if (!vn_cs_renderer_protocol_has_extension(392 /* VK_EXT_image_view_min_lod */))
14816 break;
14817 vn_encode_simple_pointer(enc, pnext);
14818 vn_encode_VkStructureType(enc, &pnext->sType);
14819 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14820 vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(enc, (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)pnext);
14821 return;
14822 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
14823 if (!vn_cs_renderer_protocol_has_extension(464 /* VK_EXT_rasterization_order_attachment_access */))
14824 break;
14825 vn_encode_simple_pointer(enc, pnext);
14826 vn_encode_VkStructureType(enc, &pnext->sType);
14827 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14828 vn_encode_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT_self(enc, (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)pnext);
14829 return;
14830 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
14831 if (!vn_cs_renderer_protocol_has_extension(321 /* VK_EXT_graphics_pipeline_library */))
14832 break;
14833 vn_encode_simple_pointer(enc, pnext);
14834 vn_encode_VkStructureType(enc, &pnext->sType);
14835 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14836 vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT_self(enc, (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)pnext);
14837 return;
14838 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
14839 if (!vn_cs_renderer_protocol_has_extension(423 /* VK_EXT_non_seamless_cube_map */))
14840 break;
14841 vn_encode_simple_pointer(enc, pnext);
14842 vn_encode_VkStructureType(enc, &pnext->sType);
14843 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14844 vn_encode_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT_self(enc, (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)pnext);
14845 return;
14846 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
14847 if (!vn_cs_renderer_protocol_has_extension(340 /* VK_EXT_attachment_feedback_loop_layout */))
14848 break;
14849 vn_encode_simple_pointer(enc, pnext);
14850 vn_encode_VkStructureType(enc, &pnext->sType);
14851 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14852 vn_encode_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT_self(enc, (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)pnext);
14853 return;
14854 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
14855 if (!vn_cs_renderer_protocol_has_extension(500 /* VK_EXT_dynamic_rendering_unused_attachments */))
14856 break;
14857 vn_encode_simple_pointer(enc, pnext);
14858 vn_encode_VkStructureType(enc, &pnext->sType);
14859 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
14860 vn_encode_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT_self(enc, (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)pnext);
14861 return;
14862 default:
14863 /* ignore unknown/unsupported struct */
14864 break;
14865 }
14866 pnext = pnext->pNext;
14867 }
14868
14869 vn_encode_simple_pointer(enc, NULL);
14870 }
14871
14872 static inline void
vn_encode_VkDeviceCreateInfo_self(struct vn_cs_encoder * enc,const VkDeviceCreateInfo * val)14873 vn_encode_VkDeviceCreateInfo_self(struct vn_cs_encoder *enc, const VkDeviceCreateInfo *val)
14874 {
14875 /* skip val->{sType,pNext} */
14876 vn_encode_VkFlags(enc, &val->flags);
14877 vn_encode_uint32_t(enc, &val->queueCreateInfoCount);
14878 if (val->pQueueCreateInfos) {
14879 vn_encode_array_size(enc, val->queueCreateInfoCount);
14880 for (uint32_t i = 0; i < val->queueCreateInfoCount; i++)
14881 vn_encode_VkDeviceQueueCreateInfo(enc, &val->pQueueCreateInfos[i]);
14882 } else {
14883 vn_encode_array_size(enc, 0);
14884 }
14885 vn_encode_uint32_t(enc, &val->enabledLayerCount);
14886 if (val->ppEnabledLayerNames) {
14887 vn_encode_array_size(enc, val->enabledLayerCount);
14888 for (uint32_t i = 0; i < val->enabledLayerCount; i++) {
14889 const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1;
14890 vn_encode_array_size(enc, string_size);
14891 vn_encode_char_array(enc, val->ppEnabledLayerNames[i], string_size);
14892 }
14893 } else {
14894 vn_encode_array_size(enc, 0);
14895 }
14896 vn_encode_uint32_t(enc, &val->enabledExtensionCount);
14897 if (val->ppEnabledExtensionNames) {
14898 vn_encode_array_size(enc, val->enabledExtensionCount);
14899 for (uint32_t i = 0; i < val->enabledExtensionCount; i++) {
14900 const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1;
14901 vn_encode_array_size(enc, string_size);
14902 vn_encode_char_array(enc, val->ppEnabledExtensionNames[i], string_size);
14903 }
14904 } else {
14905 vn_encode_array_size(enc, 0);
14906 }
14907 if (vn_encode_simple_pointer(enc, val->pEnabledFeatures))
14908 vn_encode_VkPhysicalDeviceFeatures(enc, val->pEnabledFeatures);
14909 }
14910
14911 static inline void
vn_encode_VkDeviceCreateInfo(struct vn_cs_encoder * enc,const VkDeviceCreateInfo * val)14912 vn_encode_VkDeviceCreateInfo(struct vn_cs_encoder *enc, const VkDeviceCreateInfo *val)
14913 {
14914 assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO);
14915 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO });
14916 vn_encode_VkDeviceCreateInfo_pnext(enc, val->pNext);
14917 vn_encode_VkDeviceCreateInfo_self(enc, val);
14918 }
14919
14920 /* struct VkPhysicalDeviceMultiDrawPropertiesEXT chain */
14921
14922 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiDrawPropertiesEXT_pnext(const void * val)14923 vn_sizeof_VkPhysicalDeviceMultiDrawPropertiesEXT_pnext(const void *val)
14924 {
14925 /* no known/supported struct */
14926 return vn_sizeof_simple_pointer(NULL);
14927 }
14928
14929 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiDrawPropertiesEXT_self(const VkPhysicalDeviceMultiDrawPropertiesEXT * val)14930 vn_sizeof_VkPhysicalDeviceMultiDrawPropertiesEXT_self(const VkPhysicalDeviceMultiDrawPropertiesEXT *val)
14931 {
14932 size_t size = 0;
14933 /* skip val->{sType,pNext} */
14934 size += vn_sizeof_uint32_t(&val->maxMultiDrawCount);
14935 return size;
14936 }
14937
14938 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiDrawPropertiesEXT(const VkPhysicalDeviceMultiDrawPropertiesEXT * val)14939 vn_sizeof_VkPhysicalDeviceMultiDrawPropertiesEXT(const VkPhysicalDeviceMultiDrawPropertiesEXT *val)
14940 {
14941 size_t size = 0;
14942
14943 size += vn_sizeof_VkStructureType(&val->sType);
14944 size += vn_sizeof_VkPhysicalDeviceMultiDrawPropertiesEXT_pnext(val->pNext);
14945 size += vn_sizeof_VkPhysicalDeviceMultiDrawPropertiesEXT_self(val);
14946
14947 return size;
14948 }
14949
14950 static inline void
vn_decode_VkPhysicalDeviceMultiDrawPropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)14951 vn_decode_VkPhysicalDeviceMultiDrawPropertiesEXT_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_VkPhysicalDeviceMultiDrawPropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiDrawPropertiesEXT * val)14959 vn_decode_VkPhysicalDeviceMultiDrawPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiDrawPropertiesEXT *val)
14960 {
14961 /* skip val->{sType,pNext} */
14962 vn_decode_uint32_t(dec, &val->maxMultiDrawCount);
14963 }
14964
14965 static inline void
vn_decode_VkPhysicalDeviceMultiDrawPropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiDrawPropertiesEXT * val)14966 vn_decode_VkPhysicalDeviceMultiDrawPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiDrawPropertiesEXT *val)
14967 {
14968 VkStructureType stype;
14969 vn_decode_VkStructureType(dec, &stype);
14970 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT);
14971
14972 assert(val->sType == stype);
14973 vn_decode_VkPhysicalDeviceMultiDrawPropertiesEXT_pnext(dec, val->pNext);
14974 vn_decode_VkPhysicalDeviceMultiDrawPropertiesEXT_self(dec, val);
14975 }
14976
14977 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiDrawPropertiesEXT_pnext_partial(const void * val)14978 vn_sizeof_VkPhysicalDeviceMultiDrawPropertiesEXT_pnext_partial(const void *val)
14979 {
14980 /* no known/supported struct */
14981 return vn_sizeof_simple_pointer(NULL);
14982 }
14983
14984 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiDrawPropertiesEXT_self_partial(const VkPhysicalDeviceMultiDrawPropertiesEXT * val)14985 vn_sizeof_VkPhysicalDeviceMultiDrawPropertiesEXT_self_partial(const VkPhysicalDeviceMultiDrawPropertiesEXT *val)
14986 {
14987 size_t size = 0;
14988 /* skip val->{sType,pNext} */
14989 /* skip val->maxMultiDrawCount */
14990 return size;
14991 }
14992
14993 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiDrawPropertiesEXT_partial(const VkPhysicalDeviceMultiDrawPropertiesEXT * val)14994 vn_sizeof_VkPhysicalDeviceMultiDrawPropertiesEXT_partial(const VkPhysicalDeviceMultiDrawPropertiesEXT *val)
14995 {
14996 size_t size = 0;
14997
14998 size += vn_sizeof_VkStructureType(&val->sType);
14999 size += vn_sizeof_VkPhysicalDeviceMultiDrawPropertiesEXT_pnext_partial(val->pNext);
15000 size += vn_sizeof_VkPhysicalDeviceMultiDrawPropertiesEXT_self_partial(val);
15001
15002 return size;
15003 }
15004
15005 static inline void
vn_encode_VkPhysicalDeviceMultiDrawPropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)15006 vn_encode_VkPhysicalDeviceMultiDrawPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
15007 {
15008 /* no known/supported struct */
15009 vn_encode_simple_pointer(enc, NULL);
15010 }
15011
15012 static inline void
vn_encode_VkPhysicalDeviceMultiDrawPropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiDrawPropertiesEXT * val)15013 vn_encode_VkPhysicalDeviceMultiDrawPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiDrawPropertiesEXT *val)
15014 {
15015 /* skip val->{sType,pNext} */
15016 /* skip val->maxMultiDrawCount */
15017 }
15018
15019 static inline void
vn_encode_VkPhysicalDeviceMultiDrawPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiDrawPropertiesEXT * val)15020 vn_encode_VkPhysicalDeviceMultiDrawPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiDrawPropertiesEXT *val)
15021 {
15022 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT);
15023 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT });
15024 vn_encode_VkPhysicalDeviceMultiDrawPropertiesEXT_pnext_partial(enc, val->pNext);
15025 vn_encode_VkPhysicalDeviceMultiDrawPropertiesEXT_self_partial(enc, val);
15026 }
15027
15028 /* struct VkPhysicalDevicePushDescriptorPropertiesKHR chain */
15029
15030 static inline size_t
vn_sizeof_VkPhysicalDevicePushDescriptorPropertiesKHR_pnext(const void * val)15031 vn_sizeof_VkPhysicalDevicePushDescriptorPropertiesKHR_pnext(const void *val)
15032 {
15033 /* no known/supported struct */
15034 return vn_sizeof_simple_pointer(NULL);
15035 }
15036
15037 static inline size_t
vn_sizeof_VkPhysicalDevicePushDescriptorPropertiesKHR_self(const VkPhysicalDevicePushDescriptorPropertiesKHR * val)15038 vn_sizeof_VkPhysicalDevicePushDescriptorPropertiesKHR_self(const VkPhysicalDevicePushDescriptorPropertiesKHR *val)
15039 {
15040 size_t size = 0;
15041 /* skip val->{sType,pNext} */
15042 size += vn_sizeof_uint32_t(&val->maxPushDescriptors);
15043 return size;
15044 }
15045
15046 static inline size_t
vn_sizeof_VkPhysicalDevicePushDescriptorPropertiesKHR(const VkPhysicalDevicePushDescriptorPropertiesKHR * val)15047 vn_sizeof_VkPhysicalDevicePushDescriptorPropertiesKHR(const VkPhysicalDevicePushDescriptorPropertiesKHR *val)
15048 {
15049 size_t size = 0;
15050
15051 size += vn_sizeof_VkStructureType(&val->sType);
15052 size += vn_sizeof_VkPhysicalDevicePushDescriptorPropertiesKHR_pnext(val->pNext);
15053 size += vn_sizeof_VkPhysicalDevicePushDescriptorPropertiesKHR_self(val);
15054
15055 return size;
15056 }
15057
15058 static inline void
vn_decode_VkPhysicalDevicePushDescriptorPropertiesKHR_pnext(struct vn_cs_decoder * dec,const void * val)15059 vn_decode_VkPhysicalDevicePushDescriptorPropertiesKHR_pnext(struct vn_cs_decoder *dec, const void *val)
15060 {
15061 /* no known/supported struct */
15062 if (vn_decode_simple_pointer(dec))
15063 assert(false);
15064 }
15065
15066 static inline void
vn_decode_VkPhysicalDevicePushDescriptorPropertiesKHR_self(struct vn_cs_decoder * dec,VkPhysicalDevicePushDescriptorPropertiesKHR * val)15067 vn_decode_VkPhysicalDevicePushDescriptorPropertiesKHR_self(struct vn_cs_decoder *dec, VkPhysicalDevicePushDescriptorPropertiesKHR *val)
15068 {
15069 /* skip val->{sType,pNext} */
15070 vn_decode_uint32_t(dec, &val->maxPushDescriptors);
15071 }
15072
15073 static inline void
vn_decode_VkPhysicalDevicePushDescriptorPropertiesKHR(struct vn_cs_decoder * dec,VkPhysicalDevicePushDescriptorPropertiesKHR * val)15074 vn_decode_VkPhysicalDevicePushDescriptorPropertiesKHR(struct vn_cs_decoder *dec, VkPhysicalDevicePushDescriptorPropertiesKHR *val)
15075 {
15076 VkStructureType stype;
15077 vn_decode_VkStructureType(dec, &stype);
15078 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR);
15079
15080 assert(val->sType == stype);
15081 vn_decode_VkPhysicalDevicePushDescriptorPropertiesKHR_pnext(dec, val->pNext);
15082 vn_decode_VkPhysicalDevicePushDescriptorPropertiesKHR_self(dec, val);
15083 }
15084
15085 static inline size_t
vn_sizeof_VkPhysicalDevicePushDescriptorPropertiesKHR_pnext_partial(const void * val)15086 vn_sizeof_VkPhysicalDevicePushDescriptorPropertiesKHR_pnext_partial(const void *val)
15087 {
15088 /* no known/supported struct */
15089 return vn_sizeof_simple_pointer(NULL);
15090 }
15091
15092 static inline size_t
vn_sizeof_VkPhysicalDevicePushDescriptorPropertiesKHR_self_partial(const VkPhysicalDevicePushDescriptorPropertiesKHR * val)15093 vn_sizeof_VkPhysicalDevicePushDescriptorPropertiesKHR_self_partial(const VkPhysicalDevicePushDescriptorPropertiesKHR *val)
15094 {
15095 size_t size = 0;
15096 /* skip val->{sType,pNext} */
15097 /* skip val->maxPushDescriptors */
15098 return size;
15099 }
15100
15101 static inline size_t
vn_sizeof_VkPhysicalDevicePushDescriptorPropertiesKHR_partial(const VkPhysicalDevicePushDescriptorPropertiesKHR * val)15102 vn_sizeof_VkPhysicalDevicePushDescriptorPropertiesKHR_partial(const VkPhysicalDevicePushDescriptorPropertiesKHR *val)
15103 {
15104 size_t size = 0;
15105
15106 size += vn_sizeof_VkStructureType(&val->sType);
15107 size += vn_sizeof_VkPhysicalDevicePushDescriptorPropertiesKHR_pnext_partial(val->pNext);
15108 size += vn_sizeof_VkPhysicalDevicePushDescriptorPropertiesKHR_self_partial(val);
15109
15110 return size;
15111 }
15112
15113 static inline void
vn_encode_VkPhysicalDevicePushDescriptorPropertiesKHR_pnext_partial(struct vn_cs_encoder * enc,const void * val)15114 vn_encode_VkPhysicalDevicePushDescriptorPropertiesKHR_pnext_partial(struct vn_cs_encoder *enc, const void *val)
15115 {
15116 /* no known/supported struct */
15117 vn_encode_simple_pointer(enc, NULL);
15118 }
15119
15120 static inline void
vn_encode_VkPhysicalDevicePushDescriptorPropertiesKHR_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePushDescriptorPropertiesKHR * val)15121 vn_encode_VkPhysicalDevicePushDescriptorPropertiesKHR_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePushDescriptorPropertiesKHR *val)
15122 {
15123 /* skip val->{sType,pNext} */
15124 /* skip val->maxPushDescriptors */
15125 }
15126
15127 static inline void
vn_encode_VkPhysicalDevicePushDescriptorPropertiesKHR_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePushDescriptorPropertiesKHR * val)15128 vn_encode_VkPhysicalDevicePushDescriptorPropertiesKHR_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePushDescriptorPropertiesKHR *val)
15129 {
15130 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR);
15131 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR });
15132 vn_encode_VkPhysicalDevicePushDescriptorPropertiesKHR_pnext_partial(enc, val->pNext);
15133 vn_encode_VkPhysicalDevicePushDescriptorPropertiesKHR_self_partial(enc, val);
15134 }
15135
15136 /* struct VkConformanceVersion */
15137
15138 static inline size_t
vn_sizeof_VkConformanceVersion(const VkConformanceVersion * val)15139 vn_sizeof_VkConformanceVersion(const VkConformanceVersion *val)
15140 {
15141 size_t size = 0;
15142 size += vn_sizeof_uint8_t(&val->major);
15143 size += vn_sizeof_uint8_t(&val->minor);
15144 size += vn_sizeof_uint8_t(&val->subminor);
15145 size += vn_sizeof_uint8_t(&val->patch);
15146 return size;
15147 }
15148
15149 static inline void
vn_decode_VkConformanceVersion(struct vn_cs_decoder * dec,VkConformanceVersion * val)15150 vn_decode_VkConformanceVersion(struct vn_cs_decoder *dec, VkConformanceVersion *val)
15151 {
15152 vn_decode_uint8_t(dec, &val->major);
15153 vn_decode_uint8_t(dec, &val->minor);
15154 vn_decode_uint8_t(dec, &val->subminor);
15155 vn_decode_uint8_t(dec, &val->patch);
15156 }
15157
15158 static inline size_t
vn_sizeof_VkConformanceVersion_partial(const VkConformanceVersion * val)15159 vn_sizeof_VkConformanceVersion_partial(const VkConformanceVersion *val)
15160 {
15161 size_t size = 0;
15162 /* skip val->major */
15163 /* skip val->minor */
15164 /* skip val->subminor */
15165 /* skip val->patch */
15166 return size;
15167 }
15168
15169 static inline void
vn_encode_VkConformanceVersion_partial(struct vn_cs_encoder * enc,const VkConformanceVersion * val)15170 vn_encode_VkConformanceVersion_partial(struct vn_cs_encoder *enc, const VkConformanceVersion *val)
15171 {
15172 /* skip val->major */
15173 /* skip val->minor */
15174 /* skip val->subminor */
15175 /* skip val->patch */
15176 }
15177
15178 /* struct VkPhysicalDeviceDriverProperties chain */
15179
15180 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_pnext(const void * val)15181 vn_sizeof_VkPhysicalDeviceDriverProperties_pnext(const void *val)
15182 {
15183 /* no known/supported struct */
15184 return vn_sizeof_simple_pointer(NULL);
15185 }
15186
15187 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_self(const VkPhysicalDeviceDriverProperties * val)15188 vn_sizeof_VkPhysicalDeviceDriverProperties_self(const VkPhysicalDeviceDriverProperties *val)
15189 {
15190 size_t size = 0;
15191 /* skip val->{sType,pNext} */
15192 size += vn_sizeof_VkDriverId(&val->driverID);
15193 size += vn_sizeof_array_size(VK_MAX_DRIVER_NAME_SIZE);
15194 size += vn_sizeof_char_array(val->driverName, VK_MAX_DRIVER_NAME_SIZE);
15195 size += vn_sizeof_array_size(VK_MAX_DRIVER_INFO_SIZE);
15196 size += vn_sizeof_char_array(val->driverInfo, VK_MAX_DRIVER_INFO_SIZE);
15197 size += vn_sizeof_VkConformanceVersion(&val->conformanceVersion);
15198 return size;
15199 }
15200
15201 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties * val)15202 vn_sizeof_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties *val)
15203 {
15204 size_t size = 0;
15205
15206 size += vn_sizeof_VkStructureType(&val->sType);
15207 size += vn_sizeof_VkPhysicalDeviceDriverProperties_pnext(val->pNext);
15208 size += vn_sizeof_VkPhysicalDeviceDriverProperties_self(val);
15209
15210 return size;
15211 }
15212
15213 static inline void
vn_decode_VkPhysicalDeviceDriverProperties_pnext(struct vn_cs_decoder * dec,const void * val)15214 vn_decode_VkPhysicalDeviceDriverProperties_pnext(struct vn_cs_decoder *dec, const void *val)
15215 {
15216 /* no known/supported struct */
15217 if (vn_decode_simple_pointer(dec))
15218 assert(false);
15219 }
15220
15221 static inline void
vn_decode_VkPhysicalDeviceDriverProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDriverProperties * val)15222 vn_decode_VkPhysicalDeviceDriverProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDriverProperties *val)
15223 {
15224 /* skip val->{sType,pNext} */
15225 vn_decode_VkDriverId(dec, &val->driverID);
15226 {
15227 const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_NAME_SIZE);
15228 vn_decode_char_array(dec, val->driverName, array_size);
15229 }
15230 {
15231 const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_INFO_SIZE);
15232 vn_decode_char_array(dec, val->driverInfo, array_size);
15233 }
15234 vn_decode_VkConformanceVersion(dec, &val->conformanceVersion);
15235 }
15236
15237 static inline void
vn_decode_VkPhysicalDeviceDriverProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceDriverProperties * val)15238 vn_decode_VkPhysicalDeviceDriverProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDriverProperties *val)
15239 {
15240 VkStructureType stype;
15241 vn_decode_VkStructureType(dec, &stype);
15242 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
15243
15244 assert(val->sType == stype);
15245 vn_decode_VkPhysicalDeviceDriverProperties_pnext(dec, val->pNext);
15246 vn_decode_VkPhysicalDeviceDriverProperties_self(dec, val);
15247 }
15248
15249 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_pnext_partial(const void * val)15250 vn_sizeof_VkPhysicalDeviceDriverProperties_pnext_partial(const void *val)
15251 {
15252 /* no known/supported struct */
15253 return vn_sizeof_simple_pointer(NULL);
15254 }
15255
15256 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial(const VkPhysicalDeviceDriverProperties * val)15257 vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial(const VkPhysicalDeviceDriverProperties *val)
15258 {
15259 size_t size = 0;
15260 /* skip val->{sType,pNext} */
15261 /* skip val->driverID */
15262 /* skip val->driverName */
15263 /* skip val->driverInfo */
15264 size += vn_sizeof_VkConformanceVersion_partial(&val->conformanceVersion);
15265 return size;
15266 }
15267
15268 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_partial(const VkPhysicalDeviceDriverProperties * val)15269 vn_sizeof_VkPhysicalDeviceDriverProperties_partial(const VkPhysicalDeviceDriverProperties *val)
15270 {
15271 size_t size = 0;
15272
15273 size += vn_sizeof_VkStructureType(&val->sType);
15274 size += vn_sizeof_VkPhysicalDeviceDriverProperties_pnext_partial(val->pNext);
15275 size += vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial(val);
15276
15277 return size;
15278 }
15279
15280 static inline void
vn_encode_VkPhysicalDeviceDriverProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)15281 vn_encode_VkPhysicalDeviceDriverProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
15282 {
15283 /* no known/supported struct */
15284 vn_encode_simple_pointer(enc, NULL);
15285 }
15286
15287 static inline void
vn_encode_VkPhysicalDeviceDriverProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDriverProperties * val)15288 vn_encode_VkPhysicalDeviceDriverProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDriverProperties *val)
15289 {
15290 /* skip val->{sType,pNext} */
15291 /* skip val->driverID */
15292 /* skip val->driverName */
15293 /* skip val->driverInfo */
15294 vn_encode_VkConformanceVersion_partial(enc, &val->conformanceVersion);
15295 }
15296
15297 static inline void
vn_encode_VkPhysicalDeviceDriverProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDriverProperties * val)15298 vn_encode_VkPhysicalDeviceDriverProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDriverProperties *val)
15299 {
15300 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
15301 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES });
15302 vn_encode_VkPhysicalDeviceDriverProperties_pnext_partial(enc, val->pNext);
15303 vn_encode_VkPhysicalDeviceDriverProperties_self_partial(enc, val);
15304 }
15305
15306 /* struct VkPhysicalDeviceIDProperties chain */
15307
15308 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_pnext(const void * val)15309 vn_sizeof_VkPhysicalDeviceIDProperties_pnext(const void *val)
15310 {
15311 /* no known/supported struct */
15312 return vn_sizeof_simple_pointer(NULL);
15313 }
15314
15315 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_self(const VkPhysicalDeviceIDProperties * val)15316 vn_sizeof_VkPhysicalDeviceIDProperties_self(const VkPhysicalDeviceIDProperties *val)
15317 {
15318 size_t size = 0;
15319 /* skip val->{sType,pNext} */
15320 size += vn_sizeof_array_size(VK_UUID_SIZE);
15321 size += vn_sizeof_uint8_t_array(val->deviceUUID, VK_UUID_SIZE);
15322 size += vn_sizeof_array_size(VK_UUID_SIZE);
15323 size += vn_sizeof_uint8_t_array(val->driverUUID, VK_UUID_SIZE);
15324 size += vn_sizeof_array_size(VK_LUID_SIZE);
15325 size += vn_sizeof_uint8_t_array(val->deviceLUID, VK_LUID_SIZE);
15326 size += vn_sizeof_uint32_t(&val->deviceNodeMask);
15327 size += vn_sizeof_VkBool32(&val->deviceLUIDValid);
15328 return size;
15329 }
15330
15331 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties * val)15332 vn_sizeof_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties *val)
15333 {
15334 size_t size = 0;
15335
15336 size += vn_sizeof_VkStructureType(&val->sType);
15337 size += vn_sizeof_VkPhysicalDeviceIDProperties_pnext(val->pNext);
15338 size += vn_sizeof_VkPhysicalDeviceIDProperties_self(val);
15339
15340 return size;
15341 }
15342
15343 static inline void
vn_decode_VkPhysicalDeviceIDProperties_pnext(struct vn_cs_decoder * dec,const void * val)15344 vn_decode_VkPhysicalDeviceIDProperties_pnext(struct vn_cs_decoder *dec, const void *val)
15345 {
15346 /* no known/supported struct */
15347 if (vn_decode_simple_pointer(dec))
15348 assert(false);
15349 }
15350
15351 static inline void
vn_decode_VkPhysicalDeviceIDProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceIDProperties * val)15352 vn_decode_VkPhysicalDeviceIDProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceIDProperties *val)
15353 {
15354 /* skip val->{sType,pNext} */
15355 {
15356 const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
15357 vn_decode_uint8_t_array(dec, val->deviceUUID, array_size);
15358 }
15359 {
15360 const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
15361 vn_decode_uint8_t_array(dec, val->driverUUID, array_size);
15362 }
15363 {
15364 const size_t array_size = vn_decode_array_size(dec, VK_LUID_SIZE);
15365 vn_decode_uint8_t_array(dec, val->deviceLUID, array_size);
15366 }
15367 vn_decode_uint32_t(dec, &val->deviceNodeMask);
15368 vn_decode_VkBool32(dec, &val->deviceLUIDValid);
15369 }
15370
15371 static inline void
vn_decode_VkPhysicalDeviceIDProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceIDProperties * val)15372 vn_decode_VkPhysicalDeviceIDProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceIDProperties *val)
15373 {
15374 VkStructureType stype;
15375 vn_decode_VkStructureType(dec, &stype);
15376 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
15377
15378 assert(val->sType == stype);
15379 vn_decode_VkPhysicalDeviceIDProperties_pnext(dec, val->pNext);
15380 vn_decode_VkPhysicalDeviceIDProperties_self(dec, val);
15381 }
15382
15383 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_pnext_partial(const void * val)15384 vn_sizeof_VkPhysicalDeviceIDProperties_pnext_partial(const void *val)
15385 {
15386 /* no known/supported struct */
15387 return vn_sizeof_simple_pointer(NULL);
15388 }
15389
15390 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_self_partial(const VkPhysicalDeviceIDProperties * val)15391 vn_sizeof_VkPhysicalDeviceIDProperties_self_partial(const VkPhysicalDeviceIDProperties *val)
15392 {
15393 size_t size = 0;
15394 /* skip val->{sType,pNext} */
15395 /* skip val->deviceUUID */
15396 /* skip val->driverUUID */
15397 /* skip val->deviceLUID */
15398 /* skip val->deviceNodeMask */
15399 /* skip val->deviceLUIDValid */
15400 return size;
15401 }
15402
15403 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_partial(const VkPhysicalDeviceIDProperties * val)15404 vn_sizeof_VkPhysicalDeviceIDProperties_partial(const VkPhysicalDeviceIDProperties *val)
15405 {
15406 size_t size = 0;
15407
15408 size += vn_sizeof_VkStructureType(&val->sType);
15409 size += vn_sizeof_VkPhysicalDeviceIDProperties_pnext_partial(val->pNext);
15410 size += vn_sizeof_VkPhysicalDeviceIDProperties_self_partial(val);
15411
15412 return size;
15413 }
15414
15415 static inline void
vn_encode_VkPhysicalDeviceIDProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)15416 vn_encode_VkPhysicalDeviceIDProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
15417 {
15418 /* no known/supported struct */
15419 vn_encode_simple_pointer(enc, NULL);
15420 }
15421
15422 static inline void
vn_encode_VkPhysicalDeviceIDProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceIDProperties * val)15423 vn_encode_VkPhysicalDeviceIDProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceIDProperties *val)
15424 {
15425 /* skip val->{sType,pNext} */
15426 /* skip val->deviceUUID */
15427 /* skip val->driverUUID */
15428 /* skip val->deviceLUID */
15429 /* skip val->deviceNodeMask */
15430 /* skip val->deviceLUIDValid */
15431 }
15432
15433 static inline void
vn_encode_VkPhysicalDeviceIDProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceIDProperties * val)15434 vn_encode_VkPhysicalDeviceIDProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceIDProperties *val)
15435 {
15436 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
15437 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES });
15438 vn_encode_VkPhysicalDeviceIDProperties_pnext_partial(enc, val->pNext);
15439 vn_encode_VkPhysicalDeviceIDProperties_self_partial(enc, val);
15440 }
15441
15442 /* struct VkPhysicalDeviceMultiviewProperties chain */
15443
15444 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext(const void * val)15445 vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext(const void *val)
15446 {
15447 /* no known/supported struct */
15448 return vn_sizeof_simple_pointer(NULL);
15449 }
15450
15451 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_self(const VkPhysicalDeviceMultiviewProperties * val)15452 vn_sizeof_VkPhysicalDeviceMultiviewProperties_self(const VkPhysicalDeviceMultiviewProperties *val)
15453 {
15454 size_t size = 0;
15455 /* skip val->{sType,pNext} */
15456 size += vn_sizeof_uint32_t(&val->maxMultiviewViewCount);
15457 size += vn_sizeof_uint32_t(&val->maxMultiviewInstanceIndex);
15458 return size;
15459 }
15460
15461 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties * val)15462 vn_sizeof_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties *val)
15463 {
15464 size_t size = 0;
15465
15466 size += vn_sizeof_VkStructureType(&val->sType);
15467 size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext(val->pNext);
15468 size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self(val);
15469
15470 return size;
15471 }
15472
15473 static inline void
vn_decode_VkPhysicalDeviceMultiviewProperties_pnext(struct vn_cs_decoder * dec,const void * val)15474 vn_decode_VkPhysicalDeviceMultiviewProperties_pnext(struct vn_cs_decoder *dec, const void *val)
15475 {
15476 /* no known/supported struct */
15477 if (vn_decode_simple_pointer(dec))
15478 assert(false);
15479 }
15480
15481 static inline void
vn_decode_VkPhysicalDeviceMultiviewProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewProperties * val)15482 vn_decode_VkPhysicalDeviceMultiviewProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewProperties *val)
15483 {
15484 /* skip val->{sType,pNext} */
15485 vn_decode_uint32_t(dec, &val->maxMultiviewViewCount);
15486 vn_decode_uint32_t(dec, &val->maxMultiviewInstanceIndex);
15487 }
15488
15489 static inline void
vn_decode_VkPhysicalDeviceMultiviewProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewProperties * val)15490 vn_decode_VkPhysicalDeviceMultiviewProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewProperties *val)
15491 {
15492 VkStructureType stype;
15493 vn_decode_VkStructureType(dec, &stype);
15494 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
15495
15496 assert(val->sType == stype);
15497 vn_decode_VkPhysicalDeviceMultiviewProperties_pnext(dec, val->pNext);
15498 vn_decode_VkPhysicalDeviceMultiviewProperties_self(dec, val);
15499 }
15500
15501 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext_partial(const void * val)15502 vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext_partial(const void *val)
15503 {
15504 /* no known/supported struct */
15505 return vn_sizeof_simple_pointer(NULL);
15506 }
15507
15508 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial(const VkPhysicalDeviceMultiviewProperties * val)15509 vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial(const VkPhysicalDeviceMultiviewProperties *val)
15510 {
15511 size_t size = 0;
15512 /* skip val->{sType,pNext} */
15513 /* skip val->maxMultiviewViewCount */
15514 /* skip val->maxMultiviewInstanceIndex */
15515 return size;
15516 }
15517
15518 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_partial(const VkPhysicalDeviceMultiviewProperties * val)15519 vn_sizeof_VkPhysicalDeviceMultiviewProperties_partial(const VkPhysicalDeviceMultiviewProperties *val)
15520 {
15521 size_t size = 0;
15522
15523 size += vn_sizeof_VkStructureType(&val->sType);
15524 size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext_partial(val->pNext);
15525 size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial(val);
15526
15527 return size;
15528 }
15529
15530 static inline void
vn_encode_VkPhysicalDeviceMultiviewProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)15531 vn_encode_VkPhysicalDeviceMultiviewProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
15532 {
15533 /* no known/supported struct */
15534 vn_encode_simple_pointer(enc, NULL);
15535 }
15536
15537 static inline void
vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewProperties * val)15538 vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewProperties *val)
15539 {
15540 /* skip val->{sType,pNext} */
15541 /* skip val->maxMultiviewViewCount */
15542 /* skip val->maxMultiviewInstanceIndex */
15543 }
15544
15545 static inline void
vn_encode_VkPhysicalDeviceMultiviewProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewProperties * val)15546 vn_encode_VkPhysicalDeviceMultiviewProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewProperties *val)
15547 {
15548 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
15549 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES });
15550 vn_encode_VkPhysicalDeviceMultiviewProperties_pnext_partial(enc, val->pNext);
15551 vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(enc, val);
15552 }
15553
15554 /* struct VkPhysicalDeviceSubgroupProperties chain */
15555
15556 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext(const void * val)15557 vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext(const void *val)
15558 {
15559 /* no known/supported struct */
15560 return vn_sizeof_simple_pointer(NULL);
15561 }
15562
15563 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_self(const VkPhysicalDeviceSubgroupProperties * val)15564 vn_sizeof_VkPhysicalDeviceSubgroupProperties_self(const VkPhysicalDeviceSubgroupProperties *val)
15565 {
15566 size_t size = 0;
15567 /* skip val->{sType,pNext} */
15568 size += vn_sizeof_uint32_t(&val->subgroupSize);
15569 size += vn_sizeof_VkFlags(&val->supportedStages);
15570 size += vn_sizeof_VkFlags(&val->supportedOperations);
15571 size += vn_sizeof_VkBool32(&val->quadOperationsInAllStages);
15572 return size;
15573 }
15574
15575 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties * val)15576 vn_sizeof_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties *val)
15577 {
15578 size_t size = 0;
15579
15580 size += vn_sizeof_VkStructureType(&val->sType);
15581 size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext(val->pNext);
15582 size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self(val);
15583
15584 return size;
15585 }
15586
15587 static inline void
vn_decode_VkPhysicalDeviceSubgroupProperties_pnext(struct vn_cs_decoder * dec,const void * val)15588 vn_decode_VkPhysicalDeviceSubgroupProperties_pnext(struct vn_cs_decoder *dec, const void *val)
15589 {
15590 /* no known/supported struct */
15591 if (vn_decode_simple_pointer(dec))
15592 assert(false);
15593 }
15594
15595 static inline void
vn_decode_VkPhysicalDeviceSubgroupProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSubgroupProperties * val)15596 vn_decode_VkPhysicalDeviceSubgroupProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupProperties *val)
15597 {
15598 /* skip val->{sType,pNext} */
15599 vn_decode_uint32_t(dec, &val->subgroupSize);
15600 vn_decode_VkFlags(dec, &val->supportedStages);
15601 vn_decode_VkFlags(dec, &val->supportedOperations);
15602 vn_decode_VkBool32(dec, &val->quadOperationsInAllStages);
15603 }
15604
15605 static inline void
vn_decode_VkPhysicalDeviceSubgroupProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceSubgroupProperties * val)15606 vn_decode_VkPhysicalDeviceSubgroupProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupProperties *val)
15607 {
15608 VkStructureType stype;
15609 vn_decode_VkStructureType(dec, &stype);
15610 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
15611
15612 assert(val->sType == stype);
15613 vn_decode_VkPhysicalDeviceSubgroupProperties_pnext(dec, val->pNext);
15614 vn_decode_VkPhysicalDeviceSubgroupProperties_self(dec, val);
15615 }
15616
15617 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext_partial(const void * val)15618 vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext_partial(const void *val)
15619 {
15620 /* no known/supported struct */
15621 return vn_sizeof_simple_pointer(NULL);
15622 }
15623
15624 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial(const VkPhysicalDeviceSubgroupProperties * val)15625 vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial(const VkPhysicalDeviceSubgroupProperties *val)
15626 {
15627 size_t size = 0;
15628 /* skip val->{sType,pNext} */
15629 /* skip val->subgroupSize */
15630 /* skip val->supportedStages */
15631 /* skip val->supportedOperations */
15632 /* skip val->quadOperationsInAllStages */
15633 return size;
15634 }
15635
15636 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_partial(const VkPhysicalDeviceSubgroupProperties * val)15637 vn_sizeof_VkPhysicalDeviceSubgroupProperties_partial(const VkPhysicalDeviceSubgroupProperties *val)
15638 {
15639 size_t size = 0;
15640
15641 size += vn_sizeof_VkStructureType(&val->sType);
15642 size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext_partial(val->pNext);
15643 size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial(val);
15644
15645 return size;
15646 }
15647
15648 static inline void
vn_encode_VkPhysicalDeviceSubgroupProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)15649 vn_encode_VkPhysicalDeviceSubgroupProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
15650 {
15651 /* no known/supported struct */
15652 vn_encode_simple_pointer(enc, NULL);
15653 }
15654
15655 static inline void
vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupProperties * val)15656 vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupProperties *val)
15657 {
15658 /* skip val->{sType,pNext} */
15659 /* skip val->subgroupSize */
15660 /* skip val->supportedStages */
15661 /* skip val->supportedOperations */
15662 /* skip val->quadOperationsInAllStages */
15663 }
15664
15665 static inline void
vn_encode_VkPhysicalDeviceSubgroupProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupProperties * val)15666 vn_encode_VkPhysicalDeviceSubgroupProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupProperties *val)
15667 {
15668 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
15669 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES });
15670 vn_encode_VkPhysicalDeviceSubgroupProperties_pnext_partial(enc, val->pNext);
15671 vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(enc, val);
15672 }
15673
15674 /* struct VkPhysicalDevicePointClippingProperties chain */
15675
15676 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext(const void * val)15677 vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext(const void *val)
15678 {
15679 /* no known/supported struct */
15680 return vn_sizeof_simple_pointer(NULL);
15681 }
15682
15683 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_self(const VkPhysicalDevicePointClippingProperties * val)15684 vn_sizeof_VkPhysicalDevicePointClippingProperties_self(const VkPhysicalDevicePointClippingProperties *val)
15685 {
15686 size_t size = 0;
15687 /* skip val->{sType,pNext} */
15688 size += vn_sizeof_VkPointClippingBehavior(&val->pointClippingBehavior);
15689 return size;
15690 }
15691
15692 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties * val)15693 vn_sizeof_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties *val)
15694 {
15695 size_t size = 0;
15696
15697 size += vn_sizeof_VkStructureType(&val->sType);
15698 size += vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext(val->pNext);
15699 size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self(val);
15700
15701 return size;
15702 }
15703
15704 static inline void
vn_decode_VkPhysicalDevicePointClippingProperties_pnext(struct vn_cs_decoder * dec,const void * val)15705 vn_decode_VkPhysicalDevicePointClippingProperties_pnext(struct vn_cs_decoder *dec, const void *val)
15706 {
15707 /* no known/supported struct */
15708 if (vn_decode_simple_pointer(dec))
15709 assert(false);
15710 }
15711
15712 static inline void
vn_decode_VkPhysicalDevicePointClippingProperties_self(struct vn_cs_decoder * dec,VkPhysicalDevicePointClippingProperties * val)15713 vn_decode_VkPhysicalDevicePointClippingProperties_self(struct vn_cs_decoder *dec, VkPhysicalDevicePointClippingProperties *val)
15714 {
15715 /* skip val->{sType,pNext} */
15716 vn_decode_VkPointClippingBehavior(dec, &val->pointClippingBehavior);
15717 }
15718
15719 static inline void
vn_decode_VkPhysicalDevicePointClippingProperties(struct vn_cs_decoder * dec,VkPhysicalDevicePointClippingProperties * val)15720 vn_decode_VkPhysicalDevicePointClippingProperties(struct vn_cs_decoder *dec, VkPhysicalDevicePointClippingProperties *val)
15721 {
15722 VkStructureType stype;
15723 vn_decode_VkStructureType(dec, &stype);
15724 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
15725
15726 assert(val->sType == stype);
15727 vn_decode_VkPhysicalDevicePointClippingProperties_pnext(dec, val->pNext);
15728 vn_decode_VkPhysicalDevicePointClippingProperties_self(dec, val);
15729 }
15730
15731 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext_partial(const void * val)15732 vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext_partial(const void *val)
15733 {
15734 /* no known/supported struct */
15735 return vn_sizeof_simple_pointer(NULL);
15736 }
15737
15738 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial(const VkPhysicalDevicePointClippingProperties * val)15739 vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial(const VkPhysicalDevicePointClippingProperties *val)
15740 {
15741 size_t size = 0;
15742 /* skip val->{sType,pNext} */
15743 /* skip val->pointClippingBehavior */
15744 return size;
15745 }
15746
15747 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_partial(const VkPhysicalDevicePointClippingProperties * val)15748 vn_sizeof_VkPhysicalDevicePointClippingProperties_partial(const VkPhysicalDevicePointClippingProperties *val)
15749 {
15750 size_t size = 0;
15751
15752 size += vn_sizeof_VkStructureType(&val->sType);
15753 size += vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext_partial(val->pNext);
15754 size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial(val);
15755
15756 return size;
15757 }
15758
15759 static inline void
vn_encode_VkPhysicalDevicePointClippingProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)15760 vn_encode_VkPhysicalDevicePointClippingProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
15761 {
15762 /* no known/supported struct */
15763 vn_encode_simple_pointer(enc, NULL);
15764 }
15765
15766 static inline void
vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePointClippingProperties * val)15767 vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePointClippingProperties *val)
15768 {
15769 /* skip val->{sType,pNext} */
15770 /* skip val->pointClippingBehavior */
15771 }
15772
15773 static inline void
vn_encode_VkPhysicalDevicePointClippingProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePointClippingProperties * val)15774 vn_encode_VkPhysicalDevicePointClippingProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePointClippingProperties *val)
15775 {
15776 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
15777 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES });
15778 vn_encode_VkPhysicalDevicePointClippingProperties_pnext_partial(enc, val->pNext);
15779 vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(enc, val);
15780 }
15781
15782 /* struct VkPhysicalDeviceProtectedMemoryProperties chain */
15783
15784 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext(const void * val)15785 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext(const void *val)
15786 {
15787 /* no known/supported struct */
15788 return vn_sizeof_simple_pointer(NULL);
15789 }
15790
15791 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self(const VkPhysicalDeviceProtectedMemoryProperties * val)15792 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self(const VkPhysicalDeviceProtectedMemoryProperties *val)
15793 {
15794 size_t size = 0;
15795 /* skip val->{sType,pNext} */
15796 size += vn_sizeof_VkBool32(&val->protectedNoFault);
15797 return size;
15798 }
15799
15800 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties * val)15801 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties *val)
15802 {
15803 size_t size = 0;
15804
15805 size += vn_sizeof_VkStructureType(&val->sType);
15806 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext(val->pNext);
15807 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self(val);
15808
15809 return size;
15810 }
15811
15812 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext(struct vn_cs_decoder * dec,const void * val)15813 vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext(struct vn_cs_decoder *dec, const void *val)
15814 {
15815 /* no known/supported struct */
15816 if (vn_decode_simple_pointer(dec))
15817 assert(false);
15818 }
15819
15820 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryProperties * val)15821 vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryProperties *val)
15822 {
15823 /* skip val->{sType,pNext} */
15824 vn_decode_VkBool32(dec, &val->protectedNoFault);
15825 }
15826
15827 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryProperties * val)15828 vn_decode_VkPhysicalDeviceProtectedMemoryProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryProperties *val)
15829 {
15830 VkStructureType stype;
15831 vn_decode_VkStructureType(dec, &stype);
15832 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
15833
15834 assert(val->sType == stype);
15835 vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext(dec, val->pNext);
15836 vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(dec, val);
15837 }
15838
15839 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(const void * val)15840 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(const void *val)
15841 {
15842 /* no known/supported struct */
15843 return vn_sizeof_simple_pointer(NULL);
15844 }
15845
15846 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial(const VkPhysicalDeviceProtectedMemoryProperties * val)15847 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial(const VkPhysicalDeviceProtectedMemoryProperties *val)
15848 {
15849 size_t size = 0;
15850 /* skip val->{sType,pNext} */
15851 /* skip val->protectedNoFault */
15852 return size;
15853 }
15854
15855 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_partial(const VkPhysicalDeviceProtectedMemoryProperties * val)15856 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_partial(const VkPhysicalDeviceProtectedMemoryProperties *val)
15857 {
15858 size_t size = 0;
15859
15860 size += vn_sizeof_VkStructureType(&val->sType);
15861 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(val->pNext);
15862 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial(val);
15863
15864 return size;
15865 }
15866
15867 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)15868 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
15869 {
15870 /* no known/supported struct */
15871 vn_encode_simple_pointer(enc, NULL);
15872 }
15873
15874 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryProperties * val)15875 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryProperties *val)
15876 {
15877 /* skip val->{sType,pNext} */
15878 /* skip val->protectedNoFault */
15879 }
15880
15881 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryProperties * val)15882 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryProperties *val)
15883 {
15884 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
15885 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES });
15886 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(enc, val->pNext);
15887 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(enc, val);
15888 }
15889
15890 /* struct VkPhysicalDeviceSamplerFilterMinmaxProperties chain */
15891
15892 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(const void * val)15893 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(const void *val)
15894 {
15895 /* no known/supported struct */
15896 return vn_sizeof_simple_pointer(NULL);
15897 }
15898
15899 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)15900 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
15901 {
15902 size_t size = 0;
15903 /* skip val->{sType,pNext} */
15904 size += vn_sizeof_VkBool32(&val->filterMinmaxSingleComponentFormats);
15905 size += vn_sizeof_VkBool32(&val->filterMinmaxImageComponentMapping);
15906 return size;
15907 }
15908
15909 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)15910 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
15911 {
15912 size_t size = 0;
15913
15914 size += vn_sizeof_VkStructureType(&val->sType);
15915 size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(val->pNext);
15916 size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(val);
15917
15918 return size;
15919 }
15920
15921 static inline void
vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(struct vn_cs_decoder * dec,const void * val)15922 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(struct vn_cs_decoder *dec, const void *val)
15923 {
15924 /* no known/supported struct */
15925 if (vn_decode_simple_pointer(dec))
15926 assert(false);
15927 }
15928
15929 static inline void
vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerFilterMinmaxProperties * val)15930 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
15931 {
15932 /* skip val->{sType,pNext} */
15933 vn_decode_VkBool32(dec, &val->filterMinmaxSingleComponentFormats);
15934 vn_decode_VkBool32(dec, &val->filterMinmaxImageComponentMapping);
15935 }
15936
15937 static inline void
vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerFilterMinmaxProperties * val)15938 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
15939 {
15940 VkStructureType stype;
15941 vn_decode_VkStructureType(dec, &stype);
15942 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
15943
15944 assert(val->sType == stype);
15945 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(dec, val->pNext);
15946 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(dec, val);
15947 }
15948
15949 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(const void * val)15950 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(const void *val)
15951 {
15952 /* no known/supported struct */
15953 return vn_sizeof_simple_pointer(NULL);
15954 }
15955
15956 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)15957 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
15958 {
15959 size_t size = 0;
15960 /* skip val->{sType,pNext} */
15961 /* skip val->filterMinmaxSingleComponentFormats */
15962 /* skip val->filterMinmaxImageComponentMapping */
15963 return size;
15964 }
15965
15966 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)15967 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
15968 {
15969 size_t size = 0;
15970
15971 size += vn_sizeof_VkStructureType(&val->sType);
15972 size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(val->pNext);
15973 size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(val);
15974
15975 return size;
15976 }
15977
15978 static inline void
vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)15979 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
15980 {
15981 /* no known/supported struct */
15982 vn_encode_simple_pointer(enc, NULL);
15983 }
15984
15985 static inline void
vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)15986 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
15987 {
15988 /* skip val->{sType,pNext} */
15989 /* skip val->filterMinmaxSingleComponentFormats */
15990 /* skip val->filterMinmaxImageComponentMapping */
15991 }
15992
15993 static inline void
vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)15994 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
15995 {
15996 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
15997 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES });
15998 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(enc, val->pNext);
15999 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(enc, val);
16000 }
16001
16002 /* struct VkPhysicalDeviceInlineUniformBlockProperties chain */
16003
16004 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_pnext(const void * val)16005 vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_pnext(const void *val)
16006 {
16007 /* no known/supported struct */
16008 return vn_sizeof_simple_pointer(NULL);
16009 }
16010
16011 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self(const VkPhysicalDeviceInlineUniformBlockProperties * val)16012 vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self(const VkPhysicalDeviceInlineUniformBlockProperties *val)
16013 {
16014 size_t size = 0;
16015 /* skip val->{sType,pNext} */
16016 size += vn_sizeof_uint32_t(&val->maxInlineUniformBlockSize);
16017 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorInlineUniformBlocks);
16018 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks);
16019 size += vn_sizeof_uint32_t(&val->maxDescriptorSetInlineUniformBlocks);
16020 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks);
16021 return size;
16022 }
16023
16024 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties(const VkPhysicalDeviceInlineUniformBlockProperties * val)16025 vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties(const VkPhysicalDeviceInlineUniformBlockProperties *val)
16026 {
16027 size_t size = 0;
16028
16029 size += vn_sizeof_VkStructureType(&val->sType);
16030 size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_pnext(val->pNext);
16031 size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self(val);
16032
16033 return size;
16034 }
16035
16036 static inline void
vn_decode_VkPhysicalDeviceInlineUniformBlockProperties_pnext(struct vn_cs_decoder * dec,const void * val)16037 vn_decode_VkPhysicalDeviceInlineUniformBlockProperties_pnext(struct vn_cs_decoder *dec, const void *val)
16038 {
16039 /* no known/supported struct */
16040 if (vn_decode_simple_pointer(dec))
16041 assert(false);
16042 }
16043
16044 static inline void
vn_decode_VkPhysicalDeviceInlineUniformBlockProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceInlineUniformBlockProperties * val)16045 vn_decode_VkPhysicalDeviceInlineUniformBlockProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceInlineUniformBlockProperties *val)
16046 {
16047 /* skip val->{sType,pNext} */
16048 vn_decode_uint32_t(dec, &val->maxInlineUniformBlockSize);
16049 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorInlineUniformBlocks);
16050 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks);
16051 vn_decode_uint32_t(dec, &val->maxDescriptorSetInlineUniformBlocks);
16052 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks);
16053 }
16054
16055 static inline void
vn_decode_VkPhysicalDeviceInlineUniformBlockProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceInlineUniformBlockProperties * val)16056 vn_decode_VkPhysicalDeviceInlineUniformBlockProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceInlineUniformBlockProperties *val)
16057 {
16058 VkStructureType stype;
16059 vn_decode_VkStructureType(dec, &stype);
16060 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES);
16061
16062 assert(val->sType == stype);
16063 vn_decode_VkPhysicalDeviceInlineUniformBlockProperties_pnext(dec, val->pNext);
16064 vn_decode_VkPhysicalDeviceInlineUniformBlockProperties_self(dec, val);
16065 }
16066
16067 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_pnext_partial(const void * val)16068 vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_pnext_partial(const void *val)
16069 {
16070 /* no known/supported struct */
16071 return vn_sizeof_simple_pointer(NULL);
16072 }
16073
16074 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self_partial(const VkPhysicalDeviceInlineUniformBlockProperties * val)16075 vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self_partial(const VkPhysicalDeviceInlineUniformBlockProperties *val)
16076 {
16077 size_t size = 0;
16078 /* skip val->{sType,pNext} */
16079 /* skip val->maxInlineUniformBlockSize */
16080 /* skip val->maxPerStageDescriptorInlineUniformBlocks */
16081 /* skip val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks */
16082 /* skip val->maxDescriptorSetInlineUniformBlocks */
16083 /* skip val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks */
16084 return size;
16085 }
16086
16087 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_partial(const VkPhysicalDeviceInlineUniformBlockProperties * val)16088 vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_partial(const VkPhysicalDeviceInlineUniformBlockProperties *val)
16089 {
16090 size_t size = 0;
16091
16092 size += vn_sizeof_VkStructureType(&val->sType);
16093 size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_pnext_partial(val->pNext);
16094 size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self_partial(val);
16095
16096 return size;
16097 }
16098
16099 static inline void
vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)16100 vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
16101 {
16102 /* no known/supported struct */
16103 vn_encode_simple_pointer(enc, NULL);
16104 }
16105
16106 static inline void
vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceInlineUniformBlockProperties * val)16107 vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceInlineUniformBlockProperties *val)
16108 {
16109 /* skip val->{sType,pNext} */
16110 /* skip val->maxInlineUniformBlockSize */
16111 /* skip val->maxPerStageDescriptorInlineUniformBlocks */
16112 /* skip val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks */
16113 /* skip val->maxDescriptorSetInlineUniformBlocks */
16114 /* skip val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks */
16115 }
16116
16117 static inline void
vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceInlineUniformBlockProperties * val)16118 vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceInlineUniformBlockProperties *val)
16119 {
16120 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES);
16121 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES });
16122 vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_pnext_partial(enc, val->pNext);
16123 vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_self_partial(enc, val);
16124 }
16125
16126 /* struct VkPhysicalDeviceMaintenance3Properties chain */
16127
16128 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext(const void * val)16129 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext(const void *val)
16130 {
16131 /* no known/supported struct */
16132 return vn_sizeof_simple_pointer(NULL);
16133 }
16134
16135 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self(const VkPhysicalDeviceMaintenance3Properties * val)16136 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self(const VkPhysicalDeviceMaintenance3Properties *val)
16137 {
16138 size_t size = 0;
16139 /* skip val->{sType,pNext} */
16140 size += vn_sizeof_uint32_t(&val->maxPerSetDescriptors);
16141 size += vn_sizeof_VkDeviceSize(&val->maxMemoryAllocationSize);
16142 return size;
16143 }
16144
16145 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties * val)16146 vn_sizeof_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties *val)
16147 {
16148 size_t size = 0;
16149
16150 size += vn_sizeof_VkStructureType(&val->sType);
16151 size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext(val->pNext);
16152 size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self(val);
16153
16154 return size;
16155 }
16156
16157 static inline void
vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext(struct vn_cs_decoder * dec,const void * val)16158 vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext(struct vn_cs_decoder *dec, const void *val)
16159 {
16160 /* no known/supported struct */
16161 if (vn_decode_simple_pointer(dec))
16162 assert(false);
16163 }
16164
16165 static inline void
vn_decode_VkPhysicalDeviceMaintenance3Properties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance3Properties * val)16166 vn_decode_VkPhysicalDeviceMaintenance3Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance3Properties *val)
16167 {
16168 /* skip val->{sType,pNext} */
16169 vn_decode_uint32_t(dec, &val->maxPerSetDescriptors);
16170 vn_decode_VkDeviceSize(dec, &val->maxMemoryAllocationSize);
16171 }
16172
16173 static inline void
vn_decode_VkPhysicalDeviceMaintenance3Properties(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance3Properties * val)16174 vn_decode_VkPhysicalDeviceMaintenance3Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance3Properties *val)
16175 {
16176 VkStructureType stype;
16177 vn_decode_VkStructureType(dec, &stype);
16178 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
16179
16180 assert(val->sType == stype);
16181 vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext(dec, val->pNext);
16182 vn_decode_VkPhysicalDeviceMaintenance3Properties_self(dec, val);
16183 }
16184
16185 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext_partial(const void * val)16186 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext_partial(const void *val)
16187 {
16188 /* no known/supported struct */
16189 return vn_sizeof_simple_pointer(NULL);
16190 }
16191
16192 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial(const VkPhysicalDeviceMaintenance3Properties * val)16193 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial(const VkPhysicalDeviceMaintenance3Properties *val)
16194 {
16195 size_t size = 0;
16196 /* skip val->{sType,pNext} */
16197 /* skip val->maxPerSetDescriptors */
16198 /* skip val->maxMemoryAllocationSize */
16199 return size;
16200 }
16201
16202 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_partial(const VkPhysicalDeviceMaintenance3Properties * val)16203 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_partial(const VkPhysicalDeviceMaintenance3Properties *val)
16204 {
16205 size_t size = 0;
16206
16207 size += vn_sizeof_VkStructureType(&val->sType);
16208 size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext_partial(val->pNext);
16209 size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial(val);
16210
16211 return size;
16212 }
16213
16214 static inline void
vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext_partial(struct vn_cs_encoder * enc,const void * val)16215 vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
16216 {
16217 /* no known/supported struct */
16218 vn_encode_simple_pointer(enc, NULL);
16219 }
16220
16221 static inline void
vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance3Properties * val)16222 vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance3Properties *val)
16223 {
16224 /* skip val->{sType,pNext} */
16225 /* skip val->maxPerSetDescriptors */
16226 /* skip val->maxMemoryAllocationSize */
16227 }
16228
16229 static inline void
vn_encode_VkPhysicalDeviceMaintenance3Properties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance3Properties * val)16230 vn_encode_VkPhysicalDeviceMaintenance3Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance3Properties *val)
16231 {
16232 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
16233 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES });
16234 vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext_partial(enc, val->pNext);
16235 vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(enc, val);
16236 }
16237
16238 /* struct VkPhysicalDeviceMaintenance4Properties chain */
16239
16240 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Properties_pnext(const void * val)16241 vn_sizeof_VkPhysicalDeviceMaintenance4Properties_pnext(const void *val)
16242 {
16243 /* no known/supported struct */
16244 return vn_sizeof_simple_pointer(NULL);
16245 }
16246
16247 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self(const VkPhysicalDeviceMaintenance4Properties * val)16248 vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self(const VkPhysicalDeviceMaintenance4Properties *val)
16249 {
16250 size_t size = 0;
16251 /* skip val->{sType,pNext} */
16252 size += vn_sizeof_VkDeviceSize(&val->maxBufferSize);
16253 return size;
16254 }
16255
16256 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Properties(const VkPhysicalDeviceMaintenance4Properties * val)16257 vn_sizeof_VkPhysicalDeviceMaintenance4Properties(const VkPhysicalDeviceMaintenance4Properties *val)
16258 {
16259 size_t size = 0;
16260
16261 size += vn_sizeof_VkStructureType(&val->sType);
16262 size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_pnext(val->pNext);
16263 size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self(val);
16264
16265 return size;
16266 }
16267
16268 static inline void
vn_decode_VkPhysicalDeviceMaintenance4Properties_pnext(struct vn_cs_decoder * dec,const void * val)16269 vn_decode_VkPhysicalDeviceMaintenance4Properties_pnext(struct vn_cs_decoder *dec, const void *val)
16270 {
16271 /* no known/supported struct */
16272 if (vn_decode_simple_pointer(dec))
16273 assert(false);
16274 }
16275
16276 static inline void
vn_decode_VkPhysicalDeviceMaintenance4Properties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance4Properties * val)16277 vn_decode_VkPhysicalDeviceMaintenance4Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance4Properties *val)
16278 {
16279 /* skip val->{sType,pNext} */
16280 vn_decode_VkDeviceSize(dec, &val->maxBufferSize);
16281 }
16282
16283 static inline void
vn_decode_VkPhysicalDeviceMaintenance4Properties(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance4Properties * val)16284 vn_decode_VkPhysicalDeviceMaintenance4Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance4Properties *val)
16285 {
16286 VkStructureType stype;
16287 vn_decode_VkStructureType(dec, &stype);
16288 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES);
16289
16290 assert(val->sType == stype);
16291 vn_decode_VkPhysicalDeviceMaintenance4Properties_pnext(dec, val->pNext);
16292 vn_decode_VkPhysicalDeviceMaintenance4Properties_self(dec, val);
16293 }
16294
16295 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Properties_pnext_partial(const void * val)16296 vn_sizeof_VkPhysicalDeviceMaintenance4Properties_pnext_partial(const void *val)
16297 {
16298 /* no known/supported struct */
16299 return vn_sizeof_simple_pointer(NULL);
16300 }
16301
16302 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self_partial(const VkPhysicalDeviceMaintenance4Properties * val)16303 vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self_partial(const VkPhysicalDeviceMaintenance4Properties *val)
16304 {
16305 size_t size = 0;
16306 /* skip val->{sType,pNext} */
16307 /* skip val->maxBufferSize */
16308 return size;
16309 }
16310
16311 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Properties_partial(const VkPhysicalDeviceMaintenance4Properties * val)16312 vn_sizeof_VkPhysicalDeviceMaintenance4Properties_partial(const VkPhysicalDeviceMaintenance4Properties *val)
16313 {
16314 size_t size = 0;
16315
16316 size += vn_sizeof_VkStructureType(&val->sType);
16317 size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_pnext_partial(val->pNext);
16318 size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self_partial(val);
16319
16320 return size;
16321 }
16322
16323 static inline void
vn_encode_VkPhysicalDeviceMaintenance4Properties_pnext_partial(struct vn_cs_encoder * enc,const void * val)16324 vn_encode_VkPhysicalDeviceMaintenance4Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
16325 {
16326 /* no known/supported struct */
16327 vn_encode_simple_pointer(enc, NULL);
16328 }
16329
16330 static inline void
vn_encode_VkPhysicalDeviceMaintenance4Properties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance4Properties * val)16331 vn_encode_VkPhysicalDeviceMaintenance4Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance4Properties *val)
16332 {
16333 /* skip val->{sType,pNext} */
16334 /* skip val->maxBufferSize */
16335 }
16336
16337 static inline void
vn_encode_VkPhysicalDeviceMaintenance4Properties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance4Properties * val)16338 vn_encode_VkPhysicalDeviceMaintenance4Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance4Properties *val)
16339 {
16340 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES);
16341 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES });
16342 vn_encode_VkPhysicalDeviceMaintenance4Properties_pnext_partial(enc, val->pNext);
16343 vn_encode_VkPhysicalDeviceMaintenance4Properties_self_partial(enc, val);
16344 }
16345
16346 /* struct VkPhysicalDeviceMaintenance5PropertiesKHR chain */
16347
16348 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_pnext(const void * val)16349 vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_pnext(const void *val)
16350 {
16351 /* no known/supported struct */
16352 return vn_sizeof_simple_pointer(NULL);
16353 }
16354
16355 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_self(const VkPhysicalDeviceMaintenance5PropertiesKHR * val)16356 vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_self(const VkPhysicalDeviceMaintenance5PropertiesKHR *val)
16357 {
16358 size_t size = 0;
16359 /* skip val->{sType,pNext} */
16360 size += vn_sizeof_VkBool32(&val->earlyFragmentMultisampleCoverageAfterSampleCounting);
16361 size += vn_sizeof_VkBool32(&val->earlyFragmentSampleMaskTestBeforeSampleCounting);
16362 size += vn_sizeof_VkBool32(&val->depthStencilSwizzleOneSupport);
16363 size += vn_sizeof_VkBool32(&val->polygonModePointSize);
16364 size += vn_sizeof_VkBool32(&val->nonStrictSinglePixelWideLinesUseParallelogram);
16365 size += vn_sizeof_VkBool32(&val->nonStrictWideLinesUseParallelogram);
16366 return size;
16367 }
16368
16369 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR(const VkPhysicalDeviceMaintenance5PropertiesKHR * val)16370 vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR(const VkPhysicalDeviceMaintenance5PropertiesKHR *val)
16371 {
16372 size_t size = 0;
16373
16374 size += vn_sizeof_VkStructureType(&val->sType);
16375 size += vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_pnext(val->pNext);
16376 size += vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_self(val);
16377
16378 return size;
16379 }
16380
16381 static inline void
vn_decode_VkPhysicalDeviceMaintenance5PropertiesKHR_pnext(struct vn_cs_decoder * dec,const void * val)16382 vn_decode_VkPhysicalDeviceMaintenance5PropertiesKHR_pnext(struct vn_cs_decoder *dec, const void *val)
16383 {
16384 /* no known/supported struct */
16385 if (vn_decode_simple_pointer(dec))
16386 assert(false);
16387 }
16388
16389 static inline void
vn_decode_VkPhysicalDeviceMaintenance5PropertiesKHR_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance5PropertiesKHR * val)16390 vn_decode_VkPhysicalDeviceMaintenance5PropertiesKHR_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance5PropertiesKHR *val)
16391 {
16392 /* skip val->{sType,pNext} */
16393 vn_decode_VkBool32(dec, &val->earlyFragmentMultisampleCoverageAfterSampleCounting);
16394 vn_decode_VkBool32(dec, &val->earlyFragmentSampleMaskTestBeforeSampleCounting);
16395 vn_decode_VkBool32(dec, &val->depthStencilSwizzleOneSupport);
16396 vn_decode_VkBool32(dec, &val->polygonModePointSize);
16397 vn_decode_VkBool32(dec, &val->nonStrictSinglePixelWideLinesUseParallelogram);
16398 vn_decode_VkBool32(dec, &val->nonStrictWideLinesUseParallelogram);
16399 }
16400
16401 static inline void
vn_decode_VkPhysicalDeviceMaintenance5PropertiesKHR(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance5PropertiesKHR * val)16402 vn_decode_VkPhysicalDeviceMaintenance5PropertiesKHR(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance5PropertiesKHR *val)
16403 {
16404 VkStructureType stype;
16405 vn_decode_VkStructureType(dec, &stype);
16406 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR);
16407
16408 assert(val->sType == stype);
16409 vn_decode_VkPhysicalDeviceMaintenance5PropertiesKHR_pnext(dec, val->pNext);
16410 vn_decode_VkPhysicalDeviceMaintenance5PropertiesKHR_self(dec, val);
16411 }
16412
16413 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_pnext_partial(const void * val)16414 vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_pnext_partial(const void *val)
16415 {
16416 /* no known/supported struct */
16417 return vn_sizeof_simple_pointer(NULL);
16418 }
16419
16420 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_self_partial(const VkPhysicalDeviceMaintenance5PropertiesKHR * val)16421 vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_self_partial(const VkPhysicalDeviceMaintenance5PropertiesKHR *val)
16422 {
16423 size_t size = 0;
16424 /* skip val->{sType,pNext} */
16425 /* skip val->earlyFragmentMultisampleCoverageAfterSampleCounting */
16426 /* skip val->earlyFragmentSampleMaskTestBeforeSampleCounting */
16427 /* skip val->depthStencilSwizzleOneSupport */
16428 /* skip val->polygonModePointSize */
16429 /* skip val->nonStrictSinglePixelWideLinesUseParallelogram */
16430 /* skip val->nonStrictWideLinesUseParallelogram */
16431 return size;
16432 }
16433
16434 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_partial(const VkPhysicalDeviceMaintenance5PropertiesKHR * val)16435 vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_partial(const VkPhysicalDeviceMaintenance5PropertiesKHR *val)
16436 {
16437 size_t size = 0;
16438
16439 size += vn_sizeof_VkStructureType(&val->sType);
16440 size += vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_pnext_partial(val->pNext);
16441 size += vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_self_partial(val);
16442
16443 return size;
16444 }
16445
16446 static inline void
vn_encode_VkPhysicalDeviceMaintenance5PropertiesKHR_pnext_partial(struct vn_cs_encoder * enc,const void * val)16447 vn_encode_VkPhysicalDeviceMaintenance5PropertiesKHR_pnext_partial(struct vn_cs_encoder *enc, const void *val)
16448 {
16449 /* no known/supported struct */
16450 vn_encode_simple_pointer(enc, NULL);
16451 }
16452
16453 static inline void
vn_encode_VkPhysicalDeviceMaintenance5PropertiesKHR_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance5PropertiesKHR * val)16454 vn_encode_VkPhysicalDeviceMaintenance5PropertiesKHR_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance5PropertiesKHR *val)
16455 {
16456 /* skip val->{sType,pNext} */
16457 /* skip val->earlyFragmentMultisampleCoverageAfterSampleCounting */
16458 /* skip val->earlyFragmentSampleMaskTestBeforeSampleCounting */
16459 /* skip val->depthStencilSwizzleOneSupport */
16460 /* skip val->polygonModePointSize */
16461 /* skip val->nonStrictSinglePixelWideLinesUseParallelogram */
16462 /* skip val->nonStrictWideLinesUseParallelogram */
16463 }
16464
16465 static inline void
vn_encode_VkPhysicalDeviceMaintenance5PropertiesKHR_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance5PropertiesKHR * val)16466 vn_encode_VkPhysicalDeviceMaintenance5PropertiesKHR_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance5PropertiesKHR *val)
16467 {
16468 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR);
16469 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR });
16470 vn_encode_VkPhysicalDeviceMaintenance5PropertiesKHR_pnext_partial(enc, val->pNext);
16471 vn_encode_VkPhysicalDeviceMaintenance5PropertiesKHR_self_partial(enc, val);
16472 }
16473
16474 /* struct VkPhysicalDeviceFloatControlsProperties chain */
16475
16476 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext(const void * val)16477 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext(const void *val)
16478 {
16479 /* no known/supported struct */
16480 return vn_sizeof_simple_pointer(NULL);
16481 }
16482
16483 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self(const VkPhysicalDeviceFloatControlsProperties * val)16484 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self(const VkPhysicalDeviceFloatControlsProperties *val)
16485 {
16486 size_t size = 0;
16487 /* skip val->{sType,pNext} */
16488 size += vn_sizeof_VkShaderFloatControlsIndependence(&val->denormBehaviorIndependence);
16489 size += vn_sizeof_VkShaderFloatControlsIndependence(&val->roundingModeIndependence);
16490 size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat16);
16491 size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat32);
16492 size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat64);
16493 size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat16);
16494 size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat32);
16495 size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat64);
16496 size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat16);
16497 size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat32);
16498 size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat64);
16499 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat16);
16500 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat32);
16501 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat64);
16502 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat16);
16503 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat32);
16504 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat64);
16505 return size;
16506 }
16507
16508 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties * val)16509 vn_sizeof_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties *val)
16510 {
16511 size_t size = 0;
16512
16513 size += vn_sizeof_VkStructureType(&val->sType);
16514 size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext(val->pNext);
16515 size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self(val);
16516
16517 return size;
16518 }
16519
16520 static inline void
vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext(struct vn_cs_decoder * dec,const void * val)16521 vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext(struct vn_cs_decoder *dec, const void *val)
16522 {
16523 /* no known/supported struct */
16524 if (vn_decode_simple_pointer(dec))
16525 assert(false);
16526 }
16527
16528 static inline void
vn_decode_VkPhysicalDeviceFloatControlsProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceFloatControlsProperties * val)16529 vn_decode_VkPhysicalDeviceFloatControlsProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceFloatControlsProperties *val)
16530 {
16531 /* skip val->{sType,pNext} */
16532 vn_decode_VkShaderFloatControlsIndependence(dec, &val->denormBehaviorIndependence);
16533 vn_decode_VkShaderFloatControlsIndependence(dec, &val->roundingModeIndependence);
16534 vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat16);
16535 vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat32);
16536 vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat64);
16537 vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat16);
16538 vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat32);
16539 vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat64);
16540 vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat16);
16541 vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat32);
16542 vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat64);
16543 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat16);
16544 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat32);
16545 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat64);
16546 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat16);
16547 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat32);
16548 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat64);
16549 }
16550
16551 static inline void
vn_decode_VkPhysicalDeviceFloatControlsProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceFloatControlsProperties * val)16552 vn_decode_VkPhysicalDeviceFloatControlsProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceFloatControlsProperties *val)
16553 {
16554 VkStructureType stype;
16555 vn_decode_VkStructureType(dec, &stype);
16556 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
16557
16558 assert(val->sType == stype);
16559 vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext(dec, val->pNext);
16560 vn_decode_VkPhysicalDeviceFloatControlsProperties_self(dec, val);
16561 }
16562
16563 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext_partial(const void * val)16564 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext_partial(const void *val)
16565 {
16566 /* no known/supported struct */
16567 return vn_sizeof_simple_pointer(NULL);
16568 }
16569
16570 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial(const VkPhysicalDeviceFloatControlsProperties * val)16571 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial(const VkPhysicalDeviceFloatControlsProperties *val)
16572 {
16573 size_t size = 0;
16574 /* skip val->{sType,pNext} */
16575 /* skip val->denormBehaviorIndependence */
16576 /* skip val->roundingModeIndependence */
16577 /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
16578 /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
16579 /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
16580 /* skip val->shaderDenormPreserveFloat16 */
16581 /* skip val->shaderDenormPreserveFloat32 */
16582 /* skip val->shaderDenormPreserveFloat64 */
16583 /* skip val->shaderDenormFlushToZeroFloat16 */
16584 /* skip val->shaderDenormFlushToZeroFloat32 */
16585 /* skip val->shaderDenormFlushToZeroFloat64 */
16586 /* skip val->shaderRoundingModeRTEFloat16 */
16587 /* skip val->shaderRoundingModeRTEFloat32 */
16588 /* skip val->shaderRoundingModeRTEFloat64 */
16589 /* skip val->shaderRoundingModeRTZFloat16 */
16590 /* skip val->shaderRoundingModeRTZFloat32 */
16591 /* skip val->shaderRoundingModeRTZFloat64 */
16592 return size;
16593 }
16594
16595 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_partial(const VkPhysicalDeviceFloatControlsProperties * val)16596 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_partial(const VkPhysicalDeviceFloatControlsProperties *val)
16597 {
16598 size_t size = 0;
16599
16600 size += vn_sizeof_VkStructureType(&val->sType);
16601 size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext_partial(val->pNext);
16602 size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial(val);
16603
16604 return size;
16605 }
16606
16607 static inline void
vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)16608 vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
16609 {
16610 /* no known/supported struct */
16611 vn_encode_simple_pointer(enc, NULL);
16612 }
16613
16614 static inline void
vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFloatControlsProperties * val)16615 vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFloatControlsProperties *val)
16616 {
16617 /* skip val->{sType,pNext} */
16618 /* skip val->denormBehaviorIndependence */
16619 /* skip val->roundingModeIndependence */
16620 /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
16621 /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
16622 /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
16623 /* skip val->shaderDenormPreserveFloat16 */
16624 /* skip val->shaderDenormPreserveFloat32 */
16625 /* skip val->shaderDenormPreserveFloat64 */
16626 /* skip val->shaderDenormFlushToZeroFloat16 */
16627 /* skip val->shaderDenormFlushToZeroFloat32 */
16628 /* skip val->shaderDenormFlushToZeroFloat64 */
16629 /* skip val->shaderRoundingModeRTEFloat16 */
16630 /* skip val->shaderRoundingModeRTEFloat32 */
16631 /* skip val->shaderRoundingModeRTEFloat64 */
16632 /* skip val->shaderRoundingModeRTZFloat16 */
16633 /* skip val->shaderRoundingModeRTZFloat32 */
16634 /* skip val->shaderRoundingModeRTZFloat64 */
16635 }
16636
16637 static inline void
vn_encode_VkPhysicalDeviceFloatControlsProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFloatControlsProperties * val)16638 vn_encode_VkPhysicalDeviceFloatControlsProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFloatControlsProperties *val)
16639 {
16640 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
16641 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES });
16642 vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext_partial(enc, val->pNext);
16643 vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(enc, val);
16644 }
16645
16646 /* struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT chain */
16647
16648 static inline size_t
vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext(const void * val)16649 vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext(const void *val)
16650 {
16651 /* no known/supported struct */
16652 return vn_sizeof_simple_pointer(NULL);
16653 }
16654
16655 static inline size_t
vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT * val)16656 vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *val)
16657 {
16658 size_t size = 0;
16659 /* skip val->{sType,pNext} */
16660 size += vn_sizeof_float(&val->primitiveOverestimationSize);
16661 size += vn_sizeof_float(&val->maxExtraPrimitiveOverestimationSize);
16662 size += vn_sizeof_float(&val->extraPrimitiveOverestimationSizeGranularity);
16663 size += vn_sizeof_VkBool32(&val->primitiveUnderestimation);
16664 size += vn_sizeof_VkBool32(&val->conservativePointAndLineRasterization);
16665 size += vn_sizeof_VkBool32(&val->degenerateTrianglesRasterized);
16666 size += vn_sizeof_VkBool32(&val->degenerateLinesRasterized);
16667 size += vn_sizeof_VkBool32(&val->fullyCoveredFragmentShaderInputVariable);
16668 size += vn_sizeof_VkBool32(&val->conservativeRasterizationPostDepthCoverage);
16669 return size;
16670 }
16671
16672 static inline size_t
vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT * val)16673 vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *val)
16674 {
16675 size_t size = 0;
16676
16677 size += vn_sizeof_VkStructureType(&val->sType);
16678 size += vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext(val->pNext);
16679 size += vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self(val);
16680
16681 return size;
16682 }
16683
16684 static inline void
vn_decode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)16685 vn_decode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
16686 {
16687 /* no known/supported struct */
16688 if (vn_decode_simple_pointer(dec))
16689 assert(false);
16690 }
16691
16692 static inline void
vn_decode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceConservativeRasterizationPropertiesEXT * val)16693 vn_decode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceConservativeRasterizationPropertiesEXT *val)
16694 {
16695 /* skip val->{sType,pNext} */
16696 vn_decode_float(dec, &val->primitiveOverestimationSize);
16697 vn_decode_float(dec, &val->maxExtraPrimitiveOverestimationSize);
16698 vn_decode_float(dec, &val->extraPrimitiveOverestimationSizeGranularity);
16699 vn_decode_VkBool32(dec, &val->primitiveUnderestimation);
16700 vn_decode_VkBool32(dec, &val->conservativePointAndLineRasterization);
16701 vn_decode_VkBool32(dec, &val->degenerateTrianglesRasterized);
16702 vn_decode_VkBool32(dec, &val->degenerateLinesRasterized);
16703 vn_decode_VkBool32(dec, &val->fullyCoveredFragmentShaderInputVariable);
16704 vn_decode_VkBool32(dec, &val->conservativeRasterizationPostDepthCoverage);
16705 }
16706
16707 static inline void
vn_decode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceConservativeRasterizationPropertiesEXT * val)16708 vn_decode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceConservativeRasterizationPropertiesEXT *val)
16709 {
16710 VkStructureType stype;
16711 vn_decode_VkStructureType(dec, &stype);
16712 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT);
16713
16714 assert(val->sType == stype);
16715 vn_decode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext(dec, val->pNext);
16716 vn_decode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self(dec, val);
16717 }
16718
16719 static inline size_t
vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext_partial(const void * val)16720 vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext_partial(const void *val)
16721 {
16722 /* no known/supported struct */
16723 return vn_sizeof_simple_pointer(NULL);
16724 }
16725
16726 static inline size_t
vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self_partial(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT * val)16727 vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self_partial(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *val)
16728 {
16729 size_t size = 0;
16730 /* skip val->{sType,pNext} */
16731 /* skip val->primitiveOverestimationSize */
16732 /* skip val->maxExtraPrimitiveOverestimationSize */
16733 /* skip val->extraPrimitiveOverestimationSizeGranularity */
16734 /* skip val->primitiveUnderestimation */
16735 /* skip val->conservativePointAndLineRasterization */
16736 /* skip val->degenerateTrianglesRasterized */
16737 /* skip val->degenerateLinesRasterized */
16738 /* skip val->fullyCoveredFragmentShaderInputVariable */
16739 /* skip val->conservativeRasterizationPostDepthCoverage */
16740 return size;
16741 }
16742
16743 static inline size_t
vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_partial(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT * val)16744 vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_partial(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *val)
16745 {
16746 size_t size = 0;
16747
16748 size += vn_sizeof_VkStructureType(&val->sType);
16749 size += vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext_partial(val->pNext);
16750 size += vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self_partial(val);
16751
16752 return size;
16753 }
16754
16755 static inline void
vn_encode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)16756 vn_encode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
16757 {
16758 /* no known/supported struct */
16759 vn_encode_simple_pointer(enc, NULL);
16760 }
16761
16762 static inline void
vn_encode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceConservativeRasterizationPropertiesEXT * val)16763 vn_encode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *val)
16764 {
16765 /* skip val->{sType,pNext} */
16766 /* skip val->primitiveOverestimationSize */
16767 /* skip val->maxExtraPrimitiveOverestimationSize */
16768 /* skip val->extraPrimitiveOverestimationSizeGranularity */
16769 /* skip val->primitiveUnderestimation */
16770 /* skip val->conservativePointAndLineRasterization */
16771 /* skip val->degenerateTrianglesRasterized */
16772 /* skip val->degenerateLinesRasterized */
16773 /* skip val->fullyCoveredFragmentShaderInputVariable */
16774 /* skip val->conservativeRasterizationPostDepthCoverage */
16775 }
16776
16777 static inline void
vn_encode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceConservativeRasterizationPropertiesEXT * val)16778 vn_encode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *val)
16779 {
16780 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT);
16781 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT });
16782 vn_encode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext_partial(enc, val->pNext);
16783 vn_encode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self_partial(enc, val);
16784 }
16785
16786 /* struct VkPhysicalDeviceDescriptorIndexingProperties chain */
16787
16788 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext(const void * val)16789 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext(const void *val)
16790 {
16791 /* no known/supported struct */
16792 return vn_sizeof_simple_pointer(NULL);
16793 }
16794
16795 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self(const VkPhysicalDeviceDescriptorIndexingProperties * val)16796 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self(const VkPhysicalDeviceDescriptorIndexingProperties *val)
16797 {
16798 size_t size = 0;
16799 /* skip val->{sType,pNext} */
16800 size += vn_sizeof_uint32_t(&val->maxUpdateAfterBindDescriptorsInAllPools);
16801 size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexingNative);
16802 size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexingNative);
16803 size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexingNative);
16804 size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexingNative);
16805 size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexingNative);
16806 size += vn_sizeof_VkBool32(&val->robustBufferAccessUpdateAfterBind);
16807 size += vn_sizeof_VkBool32(&val->quadDivergentImplicitLod);
16808 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSamplers);
16809 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
16810 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
16811 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSampledImages);
16812 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageImages);
16813 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
16814 size += vn_sizeof_uint32_t(&val->maxPerStageUpdateAfterBindResources);
16815 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSamplers);
16816 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffers);
16817 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
16818 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffers);
16819 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
16820 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSampledImages);
16821 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageImages);
16822 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInputAttachments);
16823 return size;
16824 }
16825
16826 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties * val)16827 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties *val)
16828 {
16829 size_t size = 0;
16830
16831 size += vn_sizeof_VkStructureType(&val->sType);
16832 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext(val->pNext);
16833 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self(val);
16834
16835 return size;
16836 }
16837
16838 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(struct vn_cs_decoder * dec,const void * val)16839 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(struct vn_cs_decoder *dec, const void *val)
16840 {
16841 /* no known/supported struct */
16842 if (vn_decode_simple_pointer(dec))
16843 assert(false);
16844 }
16845
16846 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingProperties * val)16847 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingProperties *val)
16848 {
16849 /* skip val->{sType,pNext} */
16850 vn_decode_uint32_t(dec, &val->maxUpdateAfterBindDescriptorsInAllPools);
16851 vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexingNative);
16852 vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexingNative);
16853 vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexingNative);
16854 vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexingNative);
16855 vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexingNative);
16856 vn_decode_VkBool32(dec, &val->robustBufferAccessUpdateAfterBind);
16857 vn_decode_VkBool32(dec, &val->quadDivergentImplicitLod);
16858 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSamplers);
16859 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
16860 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
16861 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSampledImages);
16862 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageImages);
16863 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
16864 vn_decode_uint32_t(dec, &val->maxPerStageUpdateAfterBindResources);
16865 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSamplers);
16866 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffers);
16867 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
16868 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffers);
16869 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
16870 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSampledImages);
16871 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageImages);
16872 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInputAttachments);
16873 }
16874
16875 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingProperties * val)16876 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingProperties *val)
16877 {
16878 VkStructureType stype;
16879 vn_decode_VkStructureType(dec, &stype);
16880 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
16881
16882 assert(val->sType == stype);
16883 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(dec, val->pNext);
16884 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(dec, val);
16885 }
16886
16887 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(const void * val)16888 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(const void *val)
16889 {
16890 /* no known/supported struct */
16891 return vn_sizeof_simple_pointer(NULL);
16892 }
16893
16894 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(const VkPhysicalDeviceDescriptorIndexingProperties * val)16895 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(const VkPhysicalDeviceDescriptorIndexingProperties *val)
16896 {
16897 size_t size = 0;
16898 /* skip val->{sType,pNext} */
16899 /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
16900 /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
16901 /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
16902 /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
16903 /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
16904 /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
16905 /* skip val->robustBufferAccessUpdateAfterBind */
16906 /* skip val->quadDivergentImplicitLod */
16907 /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
16908 /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
16909 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
16910 /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
16911 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
16912 /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
16913 /* skip val->maxPerStageUpdateAfterBindResources */
16914 /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
16915 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
16916 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
16917 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
16918 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
16919 /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
16920 /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
16921 /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
16922 return size;
16923 }
16924
16925 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_partial(const VkPhysicalDeviceDescriptorIndexingProperties * val)16926 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_partial(const VkPhysicalDeviceDescriptorIndexingProperties *val)
16927 {
16928 size_t size = 0;
16929
16930 size += vn_sizeof_VkStructureType(&val->sType);
16931 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(val->pNext);
16932 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(val);
16933
16934 return size;
16935 }
16936
16937 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)16938 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
16939 {
16940 /* no known/supported struct */
16941 vn_encode_simple_pointer(enc, NULL);
16942 }
16943
16944 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingProperties * val)16945 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingProperties *val)
16946 {
16947 /* skip val->{sType,pNext} */
16948 /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
16949 /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
16950 /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
16951 /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
16952 /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
16953 /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
16954 /* skip val->robustBufferAccessUpdateAfterBind */
16955 /* skip val->quadDivergentImplicitLod */
16956 /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
16957 /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
16958 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
16959 /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
16960 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
16961 /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
16962 /* skip val->maxPerStageUpdateAfterBindResources */
16963 /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
16964 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
16965 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
16966 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
16967 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
16968 /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
16969 /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
16970 /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
16971 }
16972
16973 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingProperties * val)16974 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingProperties *val)
16975 {
16976 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
16977 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES });
16978 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(enc, val->pNext);
16979 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(enc, val);
16980 }
16981
16982 /* struct VkPhysicalDeviceTimelineSemaphoreProperties chain */
16983
16984 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(const void * val)16985 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(const void *val)
16986 {
16987 /* no known/supported struct */
16988 return vn_sizeof_simple_pointer(NULL);
16989 }
16990
16991 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self(const VkPhysicalDeviceTimelineSemaphoreProperties * val)16992 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
16993 {
16994 size_t size = 0;
16995 /* skip val->{sType,pNext} */
16996 size += vn_sizeof_uint64_t(&val->maxTimelineSemaphoreValueDifference);
16997 return size;
16998 }
16999
17000 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties * val)17001 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
17002 {
17003 size_t size = 0;
17004
17005 size += vn_sizeof_VkStructureType(&val->sType);
17006 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(val->pNext);
17007 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self(val);
17008
17009 return size;
17010 }
17011
17012 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(struct vn_cs_decoder * dec,const void * val)17013 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(struct vn_cs_decoder *dec, const void *val)
17014 {
17015 /* no known/supported struct */
17016 if (vn_decode_simple_pointer(dec))
17017 assert(false);
17018 }
17019
17020 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreProperties * val)17021 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreProperties *val)
17022 {
17023 /* skip val->{sType,pNext} */
17024 vn_decode_uint64_t(dec, &val->maxTimelineSemaphoreValueDifference);
17025 }
17026
17027 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreProperties * val)17028 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreProperties *val)
17029 {
17030 VkStructureType stype;
17031 vn_decode_VkStructureType(dec, &stype);
17032 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
17033
17034 assert(val->sType == stype);
17035 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(dec, val->pNext);
17036 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(dec, val);
17037 }
17038
17039 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(const void * val)17040 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(const void *val)
17041 {
17042 /* no known/supported struct */
17043 return vn_sizeof_simple_pointer(NULL);
17044 }
17045
17046 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(const VkPhysicalDeviceTimelineSemaphoreProperties * val)17047 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
17048 {
17049 size_t size = 0;
17050 /* skip val->{sType,pNext} */
17051 /* skip val->maxTimelineSemaphoreValueDifference */
17052 return size;
17053 }
17054
17055 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_partial(const VkPhysicalDeviceTimelineSemaphoreProperties * val)17056 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_partial(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
17057 {
17058 size_t size = 0;
17059
17060 size += vn_sizeof_VkStructureType(&val->sType);
17061 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(val->pNext);
17062 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(val);
17063
17064 return size;
17065 }
17066
17067 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)17068 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
17069 {
17070 /* no known/supported struct */
17071 vn_encode_simple_pointer(enc, NULL);
17072 }
17073
17074 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreProperties * val)17075 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreProperties *val)
17076 {
17077 /* skip val->{sType,pNext} */
17078 /* skip val->maxTimelineSemaphoreValueDifference */
17079 }
17080
17081 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreProperties * val)17082 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreProperties *val)
17083 {
17084 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
17085 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES });
17086 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(enc, val->pNext);
17087 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(enc, val);
17088 }
17089
17090 /* struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT chain */
17091
17092 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext(const void * val)17093 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext(const void *val)
17094 {
17095 /* no known/supported struct */
17096 return vn_sizeof_simple_pointer(NULL);
17097 }
17098
17099 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * val)17100 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *val)
17101 {
17102 size_t size = 0;
17103 /* skip val->{sType,pNext} */
17104 size += vn_sizeof_uint32_t(&val->maxVertexAttribDivisor);
17105 return size;
17106 }
17107
17108 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * val)17109 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *val)
17110 {
17111 size_t size = 0;
17112
17113 size += vn_sizeof_VkStructureType(&val->sType);
17114 size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext(val->pNext);
17115 size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self(val);
17116
17117 return size;
17118 }
17119
17120 static inline void
vn_decode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)17121 vn_decode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
17122 {
17123 /* no known/supported struct */
17124 if (vn_decode_simple_pointer(dec))
17125 assert(false);
17126 }
17127
17128 static inline void
vn_decode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * val)17129 vn_decode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *val)
17130 {
17131 /* skip val->{sType,pNext} */
17132 vn_decode_uint32_t(dec, &val->maxVertexAttribDivisor);
17133 }
17134
17135 static inline void
vn_decode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * val)17136 vn_decode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *val)
17137 {
17138 VkStructureType stype;
17139 vn_decode_VkStructureType(dec, &stype);
17140 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT);
17141
17142 assert(val->sType == stype);
17143 vn_decode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext(dec, val->pNext);
17144 vn_decode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self(dec, val);
17145 }
17146
17147 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext_partial(const void * val)17148 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext_partial(const void *val)
17149 {
17150 /* no known/supported struct */
17151 return vn_sizeof_simple_pointer(NULL);
17152 }
17153
17154 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self_partial(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * val)17155 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self_partial(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *val)
17156 {
17157 size_t size = 0;
17158 /* skip val->{sType,pNext} */
17159 /* skip val->maxVertexAttribDivisor */
17160 return size;
17161 }
17162
17163 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_partial(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * val)17164 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_partial(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *val)
17165 {
17166 size_t size = 0;
17167
17168 size += vn_sizeof_VkStructureType(&val->sType);
17169 size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext_partial(val->pNext);
17170 size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self_partial(val);
17171
17172 return size;
17173 }
17174
17175 static inline void
vn_encode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)17176 vn_encode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
17177 {
17178 /* no known/supported struct */
17179 vn_encode_simple_pointer(enc, NULL);
17180 }
17181
17182 static inline void
vn_encode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * val)17183 vn_encode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *val)
17184 {
17185 /* skip val->{sType,pNext} */
17186 /* skip val->maxVertexAttribDivisor */
17187 }
17188
17189 static inline void
vn_encode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * val)17190 vn_encode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *val)
17191 {
17192 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT);
17193 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT });
17194 vn_encode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext_partial(enc, val->pNext);
17195 vn_encode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self_partial(enc, val);
17196 }
17197
17198 /* struct VkPhysicalDevicePCIBusInfoPropertiesEXT chain */
17199
17200 static inline size_t
vn_sizeof_VkPhysicalDevicePCIBusInfoPropertiesEXT_pnext(const void * val)17201 vn_sizeof_VkPhysicalDevicePCIBusInfoPropertiesEXT_pnext(const void *val)
17202 {
17203 /* no known/supported struct */
17204 return vn_sizeof_simple_pointer(NULL);
17205 }
17206
17207 static inline size_t
vn_sizeof_VkPhysicalDevicePCIBusInfoPropertiesEXT_self(const VkPhysicalDevicePCIBusInfoPropertiesEXT * val)17208 vn_sizeof_VkPhysicalDevicePCIBusInfoPropertiesEXT_self(const VkPhysicalDevicePCIBusInfoPropertiesEXT *val)
17209 {
17210 size_t size = 0;
17211 /* skip val->{sType,pNext} */
17212 size += vn_sizeof_uint32_t(&val->pciDomain);
17213 size += vn_sizeof_uint32_t(&val->pciBus);
17214 size += vn_sizeof_uint32_t(&val->pciDevice);
17215 size += vn_sizeof_uint32_t(&val->pciFunction);
17216 return size;
17217 }
17218
17219 static inline size_t
vn_sizeof_VkPhysicalDevicePCIBusInfoPropertiesEXT(const VkPhysicalDevicePCIBusInfoPropertiesEXT * val)17220 vn_sizeof_VkPhysicalDevicePCIBusInfoPropertiesEXT(const VkPhysicalDevicePCIBusInfoPropertiesEXT *val)
17221 {
17222 size_t size = 0;
17223
17224 size += vn_sizeof_VkStructureType(&val->sType);
17225 size += vn_sizeof_VkPhysicalDevicePCIBusInfoPropertiesEXT_pnext(val->pNext);
17226 size += vn_sizeof_VkPhysicalDevicePCIBusInfoPropertiesEXT_self(val);
17227
17228 return size;
17229 }
17230
17231 static inline void
vn_decode_VkPhysicalDevicePCIBusInfoPropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)17232 vn_decode_VkPhysicalDevicePCIBusInfoPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
17233 {
17234 /* no known/supported struct */
17235 if (vn_decode_simple_pointer(dec))
17236 assert(false);
17237 }
17238
17239 static inline void
vn_decode_VkPhysicalDevicePCIBusInfoPropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDevicePCIBusInfoPropertiesEXT * val)17240 vn_decode_VkPhysicalDevicePCIBusInfoPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDevicePCIBusInfoPropertiesEXT *val)
17241 {
17242 /* skip val->{sType,pNext} */
17243 vn_decode_uint32_t(dec, &val->pciDomain);
17244 vn_decode_uint32_t(dec, &val->pciBus);
17245 vn_decode_uint32_t(dec, &val->pciDevice);
17246 vn_decode_uint32_t(dec, &val->pciFunction);
17247 }
17248
17249 static inline void
vn_decode_VkPhysicalDevicePCIBusInfoPropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDevicePCIBusInfoPropertiesEXT * val)17250 vn_decode_VkPhysicalDevicePCIBusInfoPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDevicePCIBusInfoPropertiesEXT *val)
17251 {
17252 VkStructureType stype;
17253 vn_decode_VkStructureType(dec, &stype);
17254 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT);
17255
17256 assert(val->sType == stype);
17257 vn_decode_VkPhysicalDevicePCIBusInfoPropertiesEXT_pnext(dec, val->pNext);
17258 vn_decode_VkPhysicalDevicePCIBusInfoPropertiesEXT_self(dec, val);
17259 }
17260
17261 static inline size_t
vn_sizeof_VkPhysicalDevicePCIBusInfoPropertiesEXT_pnext_partial(const void * val)17262 vn_sizeof_VkPhysicalDevicePCIBusInfoPropertiesEXT_pnext_partial(const void *val)
17263 {
17264 /* no known/supported struct */
17265 return vn_sizeof_simple_pointer(NULL);
17266 }
17267
17268 static inline size_t
vn_sizeof_VkPhysicalDevicePCIBusInfoPropertiesEXT_self_partial(const VkPhysicalDevicePCIBusInfoPropertiesEXT * val)17269 vn_sizeof_VkPhysicalDevicePCIBusInfoPropertiesEXT_self_partial(const VkPhysicalDevicePCIBusInfoPropertiesEXT *val)
17270 {
17271 size_t size = 0;
17272 /* skip val->{sType,pNext} */
17273 /* skip val->pciDomain */
17274 /* skip val->pciBus */
17275 /* skip val->pciDevice */
17276 /* skip val->pciFunction */
17277 return size;
17278 }
17279
17280 static inline size_t
vn_sizeof_VkPhysicalDevicePCIBusInfoPropertiesEXT_partial(const VkPhysicalDevicePCIBusInfoPropertiesEXT * val)17281 vn_sizeof_VkPhysicalDevicePCIBusInfoPropertiesEXT_partial(const VkPhysicalDevicePCIBusInfoPropertiesEXT *val)
17282 {
17283 size_t size = 0;
17284
17285 size += vn_sizeof_VkStructureType(&val->sType);
17286 size += vn_sizeof_VkPhysicalDevicePCIBusInfoPropertiesEXT_pnext_partial(val->pNext);
17287 size += vn_sizeof_VkPhysicalDevicePCIBusInfoPropertiesEXT_self_partial(val);
17288
17289 return size;
17290 }
17291
17292 static inline void
vn_encode_VkPhysicalDevicePCIBusInfoPropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)17293 vn_encode_VkPhysicalDevicePCIBusInfoPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
17294 {
17295 /* no known/supported struct */
17296 vn_encode_simple_pointer(enc, NULL);
17297 }
17298
17299 static inline void
vn_encode_VkPhysicalDevicePCIBusInfoPropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePCIBusInfoPropertiesEXT * val)17300 vn_encode_VkPhysicalDevicePCIBusInfoPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePCIBusInfoPropertiesEXT *val)
17301 {
17302 /* skip val->{sType,pNext} */
17303 /* skip val->pciDomain */
17304 /* skip val->pciBus */
17305 /* skip val->pciDevice */
17306 /* skip val->pciFunction */
17307 }
17308
17309 static inline void
vn_encode_VkPhysicalDevicePCIBusInfoPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePCIBusInfoPropertiesEXT * val)17310 vn_encode_VkPhysicalDevicePCIBusInfoPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePCIBusInfoPropertiesEXT *val)
17311 {
17312 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT);
17313 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT });
17314 vn_encode_VkPhysicalDevicePCIBusInfoPropertiesEXT_pnext_partial(enc, val->pNext);
17315 vn_encode_VkPhysicalDevicePCIBusInfoPropertiesEXT_self_partial(enc, val);
17316 }
17317
17318 /* struct VkPhysicalDeviceDepthStencilResolveProperties chain */
17319
17320 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext(const void * val)17321 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext(const void *val)
17322 {
17323 /* no known/supported struct */
17324 return vn_sizeof_simple_pointer(NULL);
17325 }
17326
17327 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self(const VkPhysicalDeviceDepthStencilResolveProperties * val)17328 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self(const VkPhysicalDeviceDepthStencilResolveProperties *val)
17329 {
17330 size_t size = 0;
17331 /* skip val->{sType,pNext} */
17332 size += vn_sizeof_VkFlags(&val->supportedDepthResolveModes);
17333 size += vn_sizeof_VkFlags(&val->supportedStencilResolveModes);
17334 size += vn_sizeof_VkBool32(&val->independentResolveNone);
17335 size += vn_sizeof_VkBool32(&val->independentResolve);
17336 return size;
17337 }
17338
17339 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties * val)17340 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties *val)
17341 {
17342 size_t size = 0;
17343
17344 size += vn_sizeof_VkStructureType(&val->sType);
17345 size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext(val->pNext);
17346 size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self(val);
17347
17348 return size;
17349 }
17350
17351 static inline void
vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(struct vn_cs_decoder * dec,const void * val)17352 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(struct vn_cs_decoder *dec, const void *val)
17353 {
17354 /* no known/supported struct */
17355 if (vn_decode_simple_pointer(dec))
17356 assert(false);
17357 }
17358
17359 static inline void
vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDepthStencilResolveProperties * val)17360 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthStencilResolveProperties *val)
17361 {
17362 /* skip val->{sType,pNext} */
17363 vn_decode_VkFlags(dec, &val->supportedDepthResolveModes);
17364 vn_decode_VkFlags(dec, &val->supportedStencilResolveModes);
17365 vn_decode_VkBool32(dec, &val->independentResolveNone);
17366 vn_decode_VkBool32(dec, &val->independentResolve);
17367 }
17368
17369 static inline void
vn_decode_VkPhysicalDeviceDepthStencilResolveProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceDepthStencilResolveProperties * val)17370 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthStencilResolveProperties *val)
17371 {
17372 VkStructureType stype;
17373 vn_decode_VkStructureType(dec, &stype);
17374 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
17375
17376 assert(val->sType == stype);
17377 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(dec, val->pNext);
17378 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(dec, val);
17379 }
17380
17381 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(const void * val)17382 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(const void *val)
17383 {
17384 /* no known/supported struct */
17385 return vn_sizeof_simple_pointer(NULL);
17386 }
17387
17388 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(const VkPhysicalDeviceDepthStencilResolveProperties * val)17389 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(const VkPhysicalDeviceDepthStencilResolveProperties *val)
17390 {
17391 size_t size = 0;
17392 /* skip val->{sType,pNext} */
17393 /* skip val->supportedDepthResolveModes */
17394 /* skip val->supportedStencilResolveModes */
17395 /* skip val->independentResolveNone */
17396 /* skip val->independentResolve */
17397 return size;
17398 }
17399
17400 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_partial(const VkPhysicalDeviceDepthStencilResolveProperties * val)17401 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_partial(const VkPhysicalDeviceDepthStencilResolveProperties *val)
17402 {
17403 size_t size = 0;
17404
17405 size += vn_sizeof_VkStructureType(&val->sType);
17406 size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(val->pNext);
17407 size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(val);
17408
17409 return size;
17410 }
17411
17412 static inline void
vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)17413 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
17414 {
17415 /* no known/supported struct */
17416 vn_encode_simple_pointer(enc, NULL);
17417 }
17418
17419 static inline void
vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthStencilResolveProperties * val)17420 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthStencilResolveProperties *val)
17421 {
17422 /* skip val->{sType,pNext} */
17423 /* skip val->supportedDepthResolveModes */
17424 /* skip val->supportedStencilResolveModes */
17425 /* skip val->independentResolveNone */
17426 /* skip val->independentResolve */
17427 }
17428
17429 static inline void
vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthStencilResolveProperties * val)17430 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthStencilResolveProperties *val)
17431 {
17432 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
17433 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES });
17434 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(enc, val->pNext);
17435 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(enc, val);
17436 }
17437
17438 /* struct VkPhysicalDeviceTransformFeedbackPropertiesEXT chain */
17439
17440 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(const void * val)17441 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(const void *val)
17442 {
17443 /* no known/supported struct */
17444 return vn_sizeof_simple_pointer(NULL);
17445 }
17446
17447 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)17448 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
17449 {
17450 size_t size = 0;
17451 /* skip val->{sType,pNext} */
17452 size += vn_sizeof_uint32_t(&val->maxTransformFeedbackStreams);
17453 size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBuffers);
17454 size += vn_sizeof_VkDeviceSize(&val->maxTransformFeedbackBufferSize);
17455 size += vn_sizeof_uint32_t(&val->maxTransformFeedbackStreamDataSize);
17456 size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBufferDataSize);
17457 size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBufferDataStride);
17458 size += vn_sizeof_VkBool32(&val->transformFeedbackQueries);
17459 size += vn_sizeof_VkBool32(&val->transformFeedbackStreamsLinesTriangles);
17460 size += vn_sizeof_VkBool32(&val->transformFeedbackRasterizationStreamSelect);
17461 size += vn_sizeof_VkBool32(&val->transformFeedbackDraw);
17462 return size;
17463 }
17464
17465 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)17466 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
17467 {
17468 size_t size = 0;
17469
17470 size += vn_sizeof_VkStructureType(&val->sType);
17471 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(val->pNext);
17472 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(val);
17473
17474 return size;
17475 }
17476
17477 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)17478 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
17479 {
17480 /* no known/supported struct */
17481 if (vn_decode_simple_pointer(dec))
17482 assert(false);
17483 }
17484
17485 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)17486 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
17487 {
17488 /* skip val->{sType,pNext} */
17489 vn_decode_uint32_t(dec, &val->maxTransformFeedbackStreams);
17490 vn_decode_uint32_t(dec, &val->maxTransformFeedbackBuffers);
17491 vn_decode_VkDeviceSize(dec, &val->maxTransformFeedbackBufferSize);
17492 vn_decode_uint32_t(dec, &val->maxTransformFeedbackStreamDataSize);
17493 vn_decode_uint32_t(dec, &val->maxTransformFeedbackBufferDataSize);
17494 vn_decode_uint32_t(dec, &val->maxTransformFeedbackBufferDataStride);
17495 vn_decode_VkBool32(dec, &val->transformFeedbackQueries);
17496 vn_decode_VkBool32(dec, &val->transformFeedbackStreamsLinesTriangles);
17497 vn_decode_VkBool32(dec, &val->transformFeedbackRasterizationStreamSelect);
17498 vn_decode_VkBool32(dec, &val->transformFeedbackDraw);
17499 }
17500
17501 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)17502 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
17503 {
17504 VkStructureType stype;
17505 vn_decode_VkStructureType(dec, &stype);
17506 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
17507
17508 assert(val->sType == stype);
17509 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(dec, val->pNext);
17510 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(dec, val);
17511 }
17512
17513 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(const void * val)17514 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(const void *val)
17515 {
17516 /* no known/supported struct */
17517 return vn_sizeof_simple_pointer(NULL);
17518 }
17519
17520 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)17521 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
17522 {
17523 size_t size = 0;
17524 /* skip val->{sType,pNext} */
17525 /* skip val->maxTransformFeedbackStreams */
17526 /* skip val->maxTransformFeedbackBuffers */
17527 /* skip val->maxTransformFeedbackBufferSize */
17528 /* skip val->maxTransformFeedbackStreamDataSize */
17529 /* skip val->maxTransformFeedbackBufferDataSize */
17530 /* skip val->maxTransformFeedbackBufferDataStride */
17531 /* skip val->transformFeedbackQueries */
17532 /* skip val->transformFeedbackStreamsLinesTriangles */
17533 /* skip val->transformFeedbackRasterizationStreamSelect */
17534 /* skip val->transformFeedbackDraw */
17535 return size;
17536 }
17537
17538 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)17539 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
17540 {
17541 size_t size = 0;
17542
17543 size += vn_sizeof_VkStructureType(&val->sType);
17544 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(val->pNext);
17545 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(val);
17546
17547 return size;
17548 }
17549
17550 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)17551 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
17552 {
17553 /* no known/supported struct */
17554 vn_encode_simple_pointer(enc, NULL);
17555 }
17556
17557 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)17558 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
17559 {
17560 /* skip val->{sType,pNext} */
17561 /* skip val->maxTransformFeedbackStreams */
17562 /* skip val->maxTransformFeedbackBuffers */
17563 /* skip val->maxTransformFeedbackBufferSize */
17564 /* skip val->maxTransformFeedbackStreamDataSize */
17565 /* skip val->maxTransformFeedbackBufferDataSize */
17566 /* skip val->maxTransformFeedbackBufferDataStride */
17567 /* skip val->transformFeedbackQueries */
17568 /* skip val->transformFeedbackStreamsLinesTriangles */
17569 /* skip val->transformFeedbackRasterizationStreamSelect */
17570 /* skip val->transformFeedbackDraw */
17571 }
17572
17573 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)17574 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
17575 {
17576 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
17577 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT });
17578 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(enc, val->pNext);
17579 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(enc, val);
17580 }
17581
17582 /* struct VkPhysicalDeviceTexelBufferAlignmentProperties chain */
17583
17584 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext(const void * val)17585 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext(const void *val)
17586 {
17587 /* no known/supported struct */
17588 return vn_sizeof_simple_pointer(NULL);
17589 }
17590
17591 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self(const VkPhysicalDeviceTexelBufferAlignmentProperties * val)17592 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self(const VkPhysicalDeviceTexelBufferAlignmentProperties *val)
17593 {
17594 size_t size = 0;
17595 /* skip val->{sType,pNext} */
17596 size += vn_sizeof_VkDeviceSize(&val->storageTexelBufferOffsetAlignmentBytes);
17597 size += vn_sizeof_VkBool32(&val->storageTexelBufferOffsetSingleTexelAlignment);
17598 size += vn_sizeof_VkDeviceSize(&val->uniformTexelBufferOffsetAlignmentBytes);
17599 size += vn_sizeof_VkBool32(&val->uniformTexelBufferOffsetSingleTexelAlignment);
17600 return size;
17601 }
17602
17603 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties(const VkPhysicalDeviceTexelBufferAlignmentProperties * val)17604 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties(const VkPhysicalDeviceTexelBufferAlignmentProperties *val)
17605 {
17606 size_t size = 0;
17607
17608 size += vn_sizeof_VkStructureType(&val->sType);
17609 size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext(val->pNext);
17610 size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self(val);
17611
17612 return size;
17613 }
17614
17615 static inline void
vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext(struct vn_cs_decoder * dec,const void * val)17616 vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext(struct vn_cs_decoder *dec, const void *val)
17617 {
17618 /* no known/supported struct */
17619 if (vn_decode_simple_pointer(dec))
17620 assert(false);
17621 }
17622
17623 static inline void
vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTexelBufferAlignmentProperties * val)17624 vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTexelBufferAlignmentProperties *val)
17625 {
17626 /* skip val->{sType,pNext} */
17627 vn_decode_VkDeviceSize(dec, &val->storageTexelBufferOffsetAlignmentBytes);
17628 vn_decode_VkBool32(dec, &val->storageTexelBufferOffsetSingleTexelAlignment);
17629 vn_decode_VkDeviceSize(dec, &val->uniformTexelBufferOffsetAlignmentBytes);
17630 vn_decode_VkBool32(dec, &val->uniformTexelBufferOffsetSingleTexelAlignment);
17631 }
17632
17633 static inline void
vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceTexelBufferAlignmentProperties * val)17634 vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceTexelBufferAlignmentProperties *val)
17635 {
17636 VkStructureType stype;
17637 vn_decode_VkStructureType(dec, &stype);
17638 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES);
17639
17640 assert(val->sType == stype);
17641 vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext(dec, val->pNext);
17642 vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties_self(dec, val);
17643 }
17644
17645 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext_partial(const void * val)17646 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext_partial(const void *val)
17647 {
17648 /* no known/supported struct */
17649 return vn_sizeof_simple_pointer(NULL);
17650 }
17651
17652 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial(const VkPhysicalDeviceTexelBufferAlignmentProperties * val)17653 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial(const VkPhysicalDeviceTexelBufferAlignmentProperties *val)
17654 {
17655 size_t size = 0;
17656 /* skip val->{sType,pNext} */
17657 /* skip val->storageTexelBufferOffsetAlignmentBytes */
17658 /* skip val->storageTexelBufferOffsetSingleTexelAlignment */
17659 /* skip val->uniformTexelBufferOffsetAlignmentBytes */
17660 /* skip val->uniformTexelBufferOffsetSingleTexelAlignment */
17661 return size;
17662 }
17663
17664 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_partial(const VkPhysicalDeviceTexelBufferAlignmentProperties * val)17665 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_partial(const VkPhysicalDeviceTexelBufferAlignmentProperties *val)
17666 {
17667 size_t size = 0;
17668
17669 size += vn_sizeof_VkStructureType(&val->sType);
17670 size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext_partial(val->pNext);
17671 size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial(val);
17672
17673 return size;
17674 }
17675
17676 static inline void
vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)17677 vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
17678 {
17679 /* no known/supported struct */
17680 vn_encode_simple_pointer(enc, NULL);
17681 }
17682
17683 static inline void
vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTexelBufferAlignmentProperties * val)17684 vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTexelBufferAlignmentProperties *val)
17685 {
17686 /* skip val->{sType,pNext} */
17687 /* skip val->storageTexelBufferOffsetAlignmentBytes */
17688 /* skip val->storageTexelBufferOffsetSingleTexelAlignment */
17689 /* skip val->uniformTexelBufferOffsetAlignmentBytes */
17690 /* skip val->uniformTexelBufferOffsetSingleTexelAlignment */
17691 }
17692
17693 static inline void
vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTexelBufferAlignmentProperties * val)17694 vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTexelBufferAlignmentProperties *val)
17695 {
17696 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES);
17697 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES });
17698 vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext_partial(enc, val->pNext);
17699 vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial(enc, val);
17700 }
17701
17702 /* struct VkPhysicalDeviceSubgroupSizeControlProperties chain */
17703
17704 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_pnext(const void * val)17705 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_pnext(const void *val)
17706 {
17707 /* no known/supported struct */
17708 return vn_sizeof_simple_pointer(NULL);
17709 }
17710
17711 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self(const VkPhysicalDeviceSubgroupSizeControlProperties * val)17712 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self(const VkPhysicalDeviceSubgroupSizeControlProperties *val)
17713 {
17714 size_t size = 0;
17715 /* skip val->{sType,pNext} */
17716 size += vn_sizeof_uint32_t(&val->minSubgroupSize);
17717 size += vn_sizeof_uint32_t(&val->maxSubgroupSize);
17718 size += vn_sizeof_uint32_t(&val->maxComputeWorkgroupSubgroups);
17719 size += vn_sizeof_VkFlags(&val->requiredSubgroupSizeStages);
17720 return size;
17721 }
17722
17723 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties(const VkPhysicalDeviceSubgroupSizeControlProperties * val)17724 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties(const VkPhysicalDeviceSubgroupSizeControlProperties *val)
17725 {
17726 size_t size = 0;
17727
17728 size += vn_sizeof_VkStructureType(&val->sType);
17729 size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_pnext(val->pNext);
17730 size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self(val);
17731
17732 return size;
17733 }
17734
17735 static inline void
vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties_pnext(struct vn_cs_decoder * dec,const void * val)17736 vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties_pnext(struct vn_cs_decoder *dec, const void *val)
17737 {
17738 /* no known/supported struct */
17739 if (vn_decode_simple_pointer(dec))
17740 assert(false);
17741 }
17742
17743 static inline void
vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSubgroupSizeControlProperties * val)17744 vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupSizeControlProperties *val)
17745 {
17746 /* skip val->{sType,pNext} */
17747 vn_decode_uint32_t(dec, &val->minSubgroupSize);
17748 vn_decode_uint32_t(dec, &val->maxSubgroupSize);
17749 vn_decode_uint32_t(dec, &val->maxComputeWorkgroupSubgroups);
17750 vn_decode_VkFlags(dec, &val->requiredSubgroupSizeStages);
17751 }
17752
17753 static inline void
vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceSubgroupSizeControlProperties * val)17754 vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupSizeControlProperties *val)
17755 {
17756 VkStructureType stype;
17757 vn_decode_VkStructureType(dec, &stype);
17758 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES);
17759
17760 assert(val->sType == stype);
17761 vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties_pnext(dec, val->pNext);
17762 vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties_self(dec, val);
17763 }
17764
17765 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_pnext_partial(const void * val)17766 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_pnext_partial(const void *val)
17767 {
17768 /* no known/supported struct */
17769 return vn_sizeof_simple_pointer(NULL);
17770 }
17771
17772 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial(const VkPhysicalDeviceSubgroupSizeControlProperties * val)17773 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial(const VkPhysicalDeviceSubgroupSizeControlProperties *val)
17774 {
17775 size_t size = 0;
17776 /* skip val->{sType,pNext} */
17777 /* skip val->minSubgroupSize */
17778 /* skip val->maxSubgroupSize */
17779 /* skip val->maxComputeWorkgroupSubgroups */
17780 /* skip val->requiredSubgroupSizeStages */
17781 return size;
17782 }
17783
17784 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_partial(const VkPhysicalDeviceSubgroupSizeControlProperties * val)17785 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_partial(const VkPhysicalDeviceSubgroupSizeControlProperties *val)
17786 {
17787 size_t size = 0;
17788
17789 size += vn_sizeof_VkStructureType(&val->sType);
17790 size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_pnext_partial(val->pNext);
17791 size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial(val);
17792
17793 return size;
17794 }
17795
17796 static inline void
vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)17797 vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
17798 {
17799 /* no known/supported struct */
17800 vn_encode_simple_pointer(enc, NULL);
17801 }
17802
17803 static inline void
vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupSizeControlProperties * val)17804 vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupSizeControlProperties *val)
17805 {
17806 /* skip val->{sType,pNext} */
17807 /* skip val->minSubgroupSize */
17808 /* skip val->maxSubgroupSize */
17809 /* skip val->maxComputeWorkgroupSubgroups */
17810 /* skip val->requiredSubgroupSizeStages */
17811 }
17812
17813 static inline void
vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupSizeControlProperties * val)17814 vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupSizeControlProperties *val)
17815 {
17816 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES);
17817 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES });
17818 vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_pnext_partial(enc, val->pNext);
17819 vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial(enc, val);
17820 }
17821
17822 /* struct VkPhysicalDeviceLineRasterizationPropertiesEXT chain */
17823
17824 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext(const void * val)17825 vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext(const void *val)
17826 {
17827 /* no known/supported struct */
17828 return vn_sizeof_simple_pointer(NULL);
17829 }
17830
17831 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_self(const VkPhysicalDeviceLineRasterizationPropertiesEXT * val)17832 vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_self(const VkPhysicalDeviceLineRasterizationPropertiesEXT *val)
17833 {
17834 size_t size = 0;
17835 /* skip val->{sType,pNext} */
17836 size += vn_sizeof_uint32_t(&val->lineSubPixelPrecisionBits);
17837 return size;
17838 }
17839
17840 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT(const VkPhysicalDeviceLineRasterizationPropertiesEXT * val)17841 vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT(const VkPhysicalDeviceLineRasterizationPropertiesEXT *val)
17842 {
17843 size_t size = 0;
17844
17845 size += vn_sizeof_VkStructureType(&val->sType);
17846 size += vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext(val->pNext);
17847 size += vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_self(val);
17848
17849 return size;
17850 }
17851
17852 static inline void
vn_decode_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)17853 vn_decode_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
17854 {
17855 /* no known/supported struct */
17856 if (vn_decode_simple_pointer(dec))
17857 assert(false);
17858 }
17859
17860 static inline void
vn_decode_VkPhysicalDeviceLineRasterizationPropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceLineRasterizationPropertiesEXT * val)17861 vn_decode_VkPhysicalDeviceLineRasterizationPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceLineRasterizationPropertiesEXT *val)
17862 {
17863 /* skip val->{sType,pNext} */
17864 vn_decode_uint32_t(dec, &val->lineSubPixelPrecisionBits);
17865 }
17866
17867 static inline void
vn_decode_VkPhysicalDeviceLineRasterizationPropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceLineRasterizationPropertiesEXT * val)17868 vn_decode_VkPhysicalDeviceLineRasterizationPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceLineRasterizationPropertiesEXT *val)
17869 {
17870 VkStructureType stype;
17871 vn_decode_VkStructureType(dec, &stype);
17872 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT);
17873
17874 assert(val->sType == stype);
17875 vn_decode_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext(dec, val->pNext);
17876 vn_decode_VkPhysicalDeviceLineRasterizationPropertiesEXT_self(dec, val);
17877 }
17878
17879 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext_partial(const void * val)17880 vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext_partial(const void *val)
17881 {
17882 /* no known/supported struct */
17883 return vn_sizeof_simple_pointer(NULL);
17884 }
17885
17886 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_self_partial(const VkPhysicalDeviceLineRasterizationPropertiesEXT * val)17887 vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_self_partial(const VkPhysicalDeviceLineRasterizationPropertiesEXT *val)
17888 {
17889 size_t size = 0;
17890 /* skip val->{sType,pNext} */
17891 /* skip val->lineSubPixelPrecisionBits */
17892 return size;
17893 }
17894
17895 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_partial(const VkPhysicalDeviceLineRasterizationPropertiesEXT * val)17896 vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_partial(const VkPhysicalDeviceLineRasterizationPropertiesEXT *val)
17897 {
17898 size_t size = 0;
17899
17900 size += vn_sizeof_VkStructureType(&val->sType);
17901 size += vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext_partial(val->pNext);
17902 size += vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_self_partial(val);
17903
17904 return size;
17905 }
17906
17907 static inline void
vn_encode_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)17908 vn_encode_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
17909 {
17910 /* no known/supported struct */
17911 vn_encode_simple_pointer(enc, NULL);
17912 }
17913
17914 static inline void
vn_encode_VkPhysicalDeviceLineRasterizationPropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceLineRasterizationPropertiesEXT * val)17915 vn_encode_VkPhysicalDeviceLineRasterizationPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceLineRasterizationPropertiesEXT *val)
17916 {
17917 /* skip val->{sType,pNext} */
17918 /* skip val->lineSubPixelPrecisionBits */
17919 }
17920
17921 static inline void
vn_encode_VkPhysicalDeviceLineRasterizationPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceLineRasterizationPropertiesEXT * val)17922 vn_encode_VkPhysicalDeviceLineRasterizationPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceLineRasterizationPropertiesEXT *val)
17923 {
17924 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT);
17925 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT });
17926 vn_encode_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext_partial(enc, val->pNext);
17927 vn_encode_VkPhysicalDeviceLineRasterizationPropertiesEXT_self_partial(enc, val);
17928 }
17929
17930 /* struct VkPhysicalDeviceVulkan11Properties chain */
17931
17932 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext(const void * val)17933 vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext(const void *val)
17934 {
17935 /* no known/supported struct */
17936 return vn_sizeof_simple_pointer(NULL);
17937 }
17938
17939 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_self(const VkPhysicalDeviceVulkan11Properties * val)17940 vn_sizeof_VkPhysicalDeviceVulkan11Properties_self(const VkPhysicalDeviceVulkan11Properties *val)
17941 {
17942 size_t size = 0;
17943 /* skip val->{sType,pNext} */
17944 size += vn_sizeof_array_size(VK_UUID_SIZE);
17945 size += vn_sizeof_uint8_t_array(val->deviceUUID, VK_UUID_SIZE);
17946 size += vn_sizeof_array_size(VK_UUID_SIZE);
17947 size += vn_sizeof_uint8_t_array(val->driverUUID, VK_UUID_SIZE);
17948 size += vn_sizeof_array_size(VK_LUID_SIZE);
17949 size += vn_sizeof_uint8_t_array(val->deviceLUID, VK_LUID_SIZE);
17950 size += vn_sizeof_uint32_t(&val->deviceNodeMask);
17951 size += vn_sizeof_VkBool32(&val->deviceLUIDValid);
17952 size += vn_sizeof_uint32_t(&val->subgroupSize);
17953 size += vn_sizeof_VkFlags(&val->subgroupSupportedStages);
17954 size += vn_sizeof_VkFlags(&val->subgroupSupportedOperations);
17955 size += vn_sizeof_VkBool32(&val->subgroupQuadOperationsInAllStages);
17956 size += vn_sizeof_VkPointClippingBehavior(&val->pointClippingBehavior);
17957 size += vn_sizeof_uint32_t(&val->maxMultiviewViewCount);
17958 size += vn_sizeof_uint32_t(&val->maxMultiviewInstanceIndex);
17959 size += vn_sizeof_VkBool32(&val->protectedNoFault);
17960 size += vn_sizeof_uint32_t(&val->maxPerSetDescriptors);
17961 size += vn_sizeof_VkDeviceSize(&val->maxMemoryAllocationSize);
17962 return size;
17963 }
17964
17965 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties * val)17966 vn_sizeof_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties *val)
17967 {
17968 size_t size = 0;
17969
17970 size += vn_sizeof_VkStructureType(&val->sType);
17971 size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext(val->pNext);
17972 size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self(val);
17973
17974 return size;
17975 }
17976
17977 static inline void
vn_decode_VkPhysicalDeviceVulkan11Properties_pnext(struct vn_cs_decoder * dec,const void * val)17978 vn_decode_VkPhysicalDeviceVulkan11Properties_pnext(struct vn_cs_decoder *dec, const void *val)
17979 {
17980 /* no known/supported struct */
17981 if (vn_decode_simple_pointer(dec))
17982 assert(false);
17983 }
17984
17985 static inline void
vn_decode_VkPhysicalDeviceVulkan11Properties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Properties * val)17986 vn_decode_VkPhysicalDeviceVulkan11Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Properties *val)
17987 {
17988 /* skip val->{sType,pNext} */
17989 {
17990 const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
17991 vn_decode_uint8_t_array(dec, val->deviceUUID, array_size);
17992 }
17993 {
17994 const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
17995 vn_decode_uint8_t_array(dec, val->driverUUID, array_size);
17996 }
17997 {
17998 const size_t array_size = vn_decode_array_size(dec, VK_LUID_SIZE);
17999 vn_decode_uint8_t_array(dec, val->deviceLUID, array_size);
18000 }
18001 vn_decode_uint32_t(dec, &val->deviceNodeMask);
18002 vn_decode_VkBool32(dec, &val->deviceLUIDValid);
18003 vn_decode_uint32_t(dec, &val->subgroupSize);
18004 vn_decode_VkFlags(dec, &val->subgroupSupportedStages);
18005 vn_decode_VkFlags(dec, &val->subgroupSupportedOperations);
18006 vn_decode_VkBool32(dec, &val->subgroupQuadOperationsInAllStages);
18007 vn_decode_VkPointClippingBehavior(dec, &val->pointClippingBehavior);
18008 vn_decode_uint32_t(dec, &val->maxMultiviewViewCount);
18009 vn_decode_uint32_t(dec, &val->maxMultiviewInstanceIndex);
18010 vn_decode_VkBool32(dec, &val->protectedNoFault);
18011 vn_decode_uint32_t(dec, &val->maxPerSetDescriptors);
18012 vn_decode_VkDeviceSize(dec, &val->maxMemoryAllocationSize);
18013 }
18014
18015 static inline void
vn_decode_VkPhysicalDeviceVulkan11Properties(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Properties * val)18016 vn_decode_VkPhysicalDeviceVulkan11Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Properties *val)
18017 {
18018 VkStructureType stype;
18019 vn_decode_VkStructureType(dec, &stype);
18020 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
18021
18022 assert(val->sType == stype);
18023 vn_decode_VkPhysicalDeviceVulkan11Properties_pnext(dec, val->pNext);
18024 vn_decode_VkPhysicalDeviceVulkan11Properties_self(dec, val);
18025 }
18026
18027 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext_partial(const void * val)18028 vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext_partial(const void *val)
18029 {
18030 /* no known/supported struct */
18031 return vn_sizeof_simple_pointer(NULL);
18032 }
18033
18034 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial(const VkPhysicalDeviceVulkan11Properties * val)18035 vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial(const VkPhysicalDeviceVulkan11Properties *val)
18036 {
18037 size_t size = 0;
18038 /* skip val->{sType,pNext} */
18039 /* skip val->deviceUUID */
18040 /* skip val->driverUUID */
18041 /* skip val->deviceLUID */
18042 /* skip val->deviceNodeMask */
18043 /* skip val->deviceLUIDValid */
18044 /* skip val->subgroupSize */
18045 /* skip val->subgroupSupportedStages */
18046 /* skip val->subgroupSupportedOperations */
18047 /* skip val->subgroupQuadOperationsInAllStages */
18048 /* skip val->pointClippingBehavior */
18049 /* skip val->maxMultiviewViewCount */
18050 /* skip val->maxMultiviewInstanceIndex */
18051 /* skip val->protectedNoFault */
18052 /* skip val->maxPerSetDescriptors */
18053 /* skip val->maxMemoryAllocationSize */
18054 return size;
18055 }
18056
18057 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_partial(const VkPhysicalDeviceVulkan11Properties * val)18058 vn_sizeof_VkPhysicalDeviceVulkan11Properties_partial(const VkPhysicalDeviceVulkan11Properties *val)
18059 {
18060 size_t size = 0;
18061
18062 size += vn_sizeof_VkStructureType(&val->sType);
18063 size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext_partial(val->pNext);
18064 size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial(val);
18065
18066 return size;
18067 }
18068
18069 static inline void
vn_encode_VkPhysicalDeviceVulkan11Properties_pnext_partial(struct vn_cs_encoder * enc,const void * val)18070 vn_encode_VkPhysicalDeviceVulkan11Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
18071 {
18072 /* no known/supported struct */
18073 vn_encode_simple_pointer(enc, NULL);
18074 }
18075
18076 static inline void
vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Properties * val)18077 vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Properties *val)
18078 {
18079 /* skip val->{sType,pNext} */
18080 /* skip val->deviceUUID */
18081 /* skip val->driverUUID */
18082 /* skip val->deviceLUID */
18083 /* skip val->deviceNodeMask */
18084 /* skip val->deviceLUIDValid */
18085 /* skip val->subgroupSize */
18086 /* skip val->subgroupSupportedStages */
18087 /* skip val->subgroupSupportedOperations */
18088 /* skip val->subgroupQuadOperationsInAllStages */
18089 /* skip val->pointClippingBehavior */
18090 /* skip val->maxMultiviewViewCount */
18091 /* skip val->maxMultiviewInstanceIndex */
18092 /* skip val->protectedNoFault */
18093 /* skip val->maxPerSetDescriptors */
18094 /* skip val->maxMemoryAllocationSize */
18095 }
18096
18097 static inline void
vn_encode_VkPhysicalDeviceVulkan11Properties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Properties * val)18098 vn_encode_VkPhysicalDeviceVulkan11Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Properties *val)
18099 {
18100 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
18101 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES });
18102 vn_encode_VkPhysicalDeviceVulkan11Properties_pnext_partial(enc, val->pNext);
18103 vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(enc, val);
18104 }
18105
18106 /* struct VkPhysicalDeviceVulkan12Properties chain */
18107
18108 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext(const void * val)18109 vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext(const void *val)
18110 {
18111 /* no known/supported struct */
18112 return vn_sizeof_simple_pointer(NULL);
18113 }
18114
18115 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_self(const VkPhysicalDeviceVulkan12Properties * val)18116 vn_sizeof_VkPhysicalDeviceVulkan12Properties_self(const VkPhysicalDeviceVulkan12Properties *val)
18117 {
18118 size_t size = 0;
18119 /* skip val->{sType,pNext} */
18120 size += vn_sizeof_VkDriverId(&val->driverID);
18121 size += vn_sizeof_array_size(VK_MAX_DRIVER_NAME_SIZE);
18122 size += vn_sizeof_char_array(val->driverName, VK_MAX_DRIVER_NAME_SIZE);
18123 size += vn_sizeof_array_size(VK_MAX_DRIVER_INFO_SIZE);
18124 size += vn_sizeof_char_array(val->driverInfo, VK_MAX_DRIVER_INFO_SIZE);
18125 size += vn_sizeof_VkConformanceVersion(&val->conformanceVersion);
18126 size += vn_sizeof_VkShaderFloatControlsIndependence(&val->denormBehaviorIndependence);
18127 size += vn_sizeof_VkShaderFloatControlsIndependence(&val->roundingModeIndependence);
18128 size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat16);
18129 size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat32);
18130 size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat64);
18131 size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat16);
18132 size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat32);
18133 size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat64);
18134 size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat16);
18135 size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat32);
18136 size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat64);
18137 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat16);
18138 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat32);
18139 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat64);
18140 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat16);
18141 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat32);
18142 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat64);
18143 size += vn_sizeof_uint32_t(&val->maxUpdateAfterBindDescriptorsInAllPools);
18144 size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexingNative);
18145 size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexingNative);
18146 size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexingNative);
18147 size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexingNative);
18148 size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexingNative);
18149 size += vn_sizeof_VkBool32(&val->robustBufferAccessUpdateAfterBind);
18150 size += vn_sizeof_VkBool32(&val->quadDivergentImplicitLod);
18151 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSamplers);
18152 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
18153 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
18154 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSampledImages);
18155 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageImages);
18156 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
18157 size += vn_sizeof_uint32_t(&val->maxPerStageUpdateAfterBindResources);
18158 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSamplers);
18159 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffers);
18160 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
18161 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffers);
18162 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
18163 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSampledImages);
18164 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageImages);
18165 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInputAttachments);
18166 size += vn_sizeof_VkFlags(&val->supportedDepthResolveModes);
18167 size += vn_sizeof_VkFlags(&val->supportedStencilResolveModes);
18168 size += vn_sizeof_VkBool32(&val->independentResolveNone);
18169 size += vn_sizeof_VkBool32(&val->independentResolve);
18170 size += vn_sizeof_VkBool32(&val->filterMinmaxSingleComponentFormats);
18171 size += vn_sizeof_VkBool32(&val->filterMinmaxImageComponentMapping);
18172 size += vn_sizeof_uint64_t(&val->maxTimelineSemaphoreValueDifference);
18173 size += vn_sizeof_VkFlags(&val->framebufferIntegerColorSampleCounts);
18174 return size;
18175 }
18176
18177 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties * val)18178 vn_sizeof_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties *val)
18179 {
18180 size_t size = 0;
18181
18182 size += vn_sizeof_VkStructureType(&val->sType);
18183 size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext(val->pNext);
18184 size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self(val);
18185
18186 return size;
18187 }
18188
18189 static inline void
vn_decode_VkPhysicalDeviceVulkan12Properties_pnext(struct vn_cs_decoder * dec,const void * val)18190 vn_decode_VkPhysicalDeviceVulkan12Properties_pnext(struct vn_cs_decoder *dec, const void *val)
18191 {
18192 /* no known/supported struct */
18193 if (vn_decode_simple_pointer(dec))
18194 assert(false);
18195 }
18196
18197 static inline void
vn_decode_VkPhysicalDeviceVulkan12Properties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Properties * val)18198 vn_decode_VkPhysicalDeviceVulkan12Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Properties *val)
18199 {
18200 /* skip val->{sType,pNext} */
18201 vn_decode_VkDriverId(dec, &val->driverID);
18202 {
18203 const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_NAME_SIZE);
18204 vn_decode_char_array(dec, val->driverName, array_size);
18205 }
18206 {
18207 const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_INFO_SIZE);
18208 vn_decode_char_array(dec, val->driverInfo, array_size);
18209 }
18210 vn_decode_VkConformanceVersion(dec, &val->conformanceVersion);
18211 vn_decode_VkShaderFloatControlsIndependence(dec, &val->denormBehaviorIndependence);
18212 vn_decode_VkShaderFloatControlsIndependence(dec, &val->roundingModeIndependence);
18213 vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat16);
18214 vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat32);
18215 vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat64);
18216 vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat16);
18217 vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat32);
18218 vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat64);
18219 vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat16);
18220 vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat32);
18221 vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat64);
18222 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat16);
18223 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat32);
18224 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat64);
18225 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat16);
18226 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat32);
18227 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat64);
18228 vn_decode_uint32_t(dec, &val->maxUpdateAfterBindDescriptorsInAllPools);
18229 vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexingNative);
18230 vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexingNative);
18231 vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexingNative);
18232 vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexingNative);
18233 vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexingNative);
18234 vn_decode_VkBool32(dec, &val->robustBufferAccessUpdateAfterBind);
18235 vn_decode_VkBool32(dec, &val->quadDivergentImplicitLod);
18236 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSamplers);
18237 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
18238 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
18239 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSampledImages);
18240 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageImages);
18241 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
18242 vn_decode_uint32_t(dec, &val->maxPerStageUpdateAfterBindResources);
18243 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSamplers);
18244 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffers);
18245 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
18246 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffers);
18247 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
18248 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSampledImages);
18249 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageImages);
18250 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInputAttachments);
18251 vn_decode_VkFlags(dec, &val->supportedDepthResolveModes);
18252 vn_decode_VkFlags(dec, &val->supportedStencilResolveModes);
18253 vn_decode_VkBool32(dec, &val->independentResolveNone);
18254 vn_decode_VkBool32(dec, &val->independentResolve);
18255 vn_decode_VkBool32(dec, &val->filterMinmaxSingleComponentFormats);
18256 vn_decode_VkBool32(dec, &val->filterMinmaxImageComponentMapping);
18257 vn_decode_uint64_t(dec, &val->maxTimelineSemaphoreValueDifference);
18258 vn_decode_VkFlags(dec, &val->framebufferIntegerColorSampleCounts);
18259 }
18260
18261 static inline void
vn_decode_VkPhysicalDeviceVulkan12Properties(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Properties * val)18262 vn_decode_VkPhysicalDeviceVulkan12Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Properties *val)
18263 {
18264 VkStructureType stype;
18265 vn_decode_VkStructureType(dec, &stype);
18266 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
18267
18268 assert(val->sType == stype);
18269 vn_decode_VkPhysicalDeviceVulkan12Properties_pnext(dec, val->pNext);
18270 vn_decode_VkPhysicalDeviceVulkan12Properties_self(dec, val);
18271 }
18272
18273 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext_partial(const void * val)18274 vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext_partial(const void *val)
18275 {
18276 /* no known/supported struct */
18277 return vn_sizeof_simple_pointer(NULL);
18278 }
18279
18280 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial(const VkPhysicalDeviceVulkan12Properties * val)18281 vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial(const VkPhysicalDeviceVulkan12Properties *val)
18282 {
18283 size_t size = 0;
18284 /* skip val->{sType,pNext} */
18285 /* skip val->driverID */
18286 /* skip val->driverName */
18287 /* skip val->driverInfo */
18288 size += vn_sizeof_VkConformanceVersion_partial(&val->conformanceVersion);
18289 /* skip val->denormBehaviorIndependence */
18290 /* skip val->roundingModeIndependence */
18291 /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
18292 /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
18293 /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
18294 /* skip val->shaderDenormPreserveFloat16 */
18295 /* skip val->shaderDenormPreserveFloat32 */
18296 /* skip val->shaderDenormPreserveFloat64 */
18297 /* skip val->shaderDenormFlushToZeroFloat16 */
18298 /* skip val->shaderDenormFlushToZeroFloat32 */
18299 /* skip val->shaderDenormFlushToZeroFloat64 */
18300 /* skip val->shaderRoundingModeRTEFloat16 */
18301 /* skip val->shaderRoundingModeRTEFloat32 */
18302 /* skip val->shaderRoundingModeRTEFloat64 */
18303 /* skip val->shaderRoundingModeRTZFloat16 */
18304 /* skip val->shaderRoundingModeRTZFloat32 */
18305 /* skip val->shaderRoundingModeRTZFloat64 */
18306 /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
18307 /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
18308 /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
18309 /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
18310 /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
18311 /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
18312 /* skip val->robustBufferAccessUpdateAfterBind */
18313 /* skip val->quadDivergentImplicitLod */
18314 /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
18315 /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
18316 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
18317 /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
18318 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
18319 /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
18320 /* skip val->maxPerStageUpdateAfterBindResources */
18321 /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
18322 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
18323 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
18324 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
18325 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
18326 /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
18327 /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
18328 /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
18329 /* skip val->supportedDepthResolveModes */
18330 /* skip val->supportedStencilResolveModes */
18331 /* skip val->independentResolveNone */
18332 /* skip val->independentResolve */
18333 /* skip val->filterMinmaxSingleComponentFormats */
18334 /* skip val->filterMinmaxImageComponentMapping */
18335 /* skip val->maxTimelineSemaphoreValueDifference */
18336 /* skip val->framebufferIntegerColorSampleCounts */
18337 return size;
18338 }
18339
18340 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_partial(const VkPhysicalDeviceVulkan12Properties * val)18341 vn_sizeof_VkPhysicalDeviceVulkan12Properties_partial(const VkPhysicalDeviceVulkan12Properties *val)
18342 {
18343 size_t size = 0;
18344
18345 size += vn_sizeof_VkStructureType(&val->sType);
18346 size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext_partial(val->pNext);
18347 size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial(val);
18348
18349 return size;
18350 }
18351
18352 static inline void
vn_encode_VkPhysicalDeviceVulkan12Properties_pnext_partial(struct vn_cs_encoder * enc,const void * val)18353 vn_encode_VkPhysicalDeviceVulkan12Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
18354 {
18355 /* no known/supported struct */
18356 vn_encode_simple_pointer(enc, NULL);
18357 }
18358
18359 static inline void
vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Properties * val)18360 vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Properties *val)
18361 {
18362 /* skip val->{sType,pNext} */
18363 /* skip val->driverID */
18364 /* skip val->driverName */
18365 /* skip val->driverInfo */
18366 vn_encode_VkConformanceVersion_partial(enc, &val->conformanceVersion);
18367 /* skip val->denormBehaviorIndependence */
18368 /* skip val->roundingModeIndependence */
18369 /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
18370 /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
18371 /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
18372 /* skip val->shaderDenormPreserveFloat16 */
18373 /* skip val->shaderDenormPreserveFloat32 */
18374 /* skip val->shaderDenormPreserveFloat64 */
18375 /* skip val->shaderDenormFlushToZeroFloat16 */
18376 /* skip val->shaderDenormFlushToZeroFloat32 */
18377 /* skip val->shaderDenormFlushToZeroFloat64 */
18378 /* skip val->shaderRoundingModeRTEFloat16 */
18379 /* skip val->shaderRoundingModeRTEFloat32 */
18380 /* skip val->shaderRoundingModeRTEFloat64 */
18381 /* skip val->shaderRoundingModeRTZFloat16 */
18382 /* skip val->shaderRoundingModeRTZFloat32 */
18383 /* skip val->shaderRoundingModeRTZFloat64 */
18384 /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
18385 /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
18386 /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
18387 /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
18388 /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
18389 /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
18390 /* skip val->robustBufferAccessUpdateAfterBind */
18391 /* skip val->quadDivergentImplicitLod */
18392 /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
18393 /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
18394 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
18395 /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
18396 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
18397 /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
18398 /* skip val->maxPerStageUpdateAfterBindResources */
18399 /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
18400 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
18401 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
18402 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
18403 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
18404 /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
18405 /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
18406 /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
18407 /* skip val->supportedDepthResolveModes */
18408 /* skip val->supportedStencilResolveModes */
18409 /* skip val->independentResolveNone */
18410 /* skip val->independentResolve */
18411 /* skip val->filterMinmaxSingleComponentFormats */
18412 /* skip val->filterMinmaxImageComponentMapping */
18413 /* skip val->maxTimelineSemaphoreValueDifference */
18414 /* skip val->framebufferIntegerColorSampleCounts */
18415 }
18416
18417 static inline void
vn_encode_VkPhysicalDeviceVulkan12Properties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Properties * val)18418 vn_encode_VkPhysicalDeviceVulkan12Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Properties *val)
18419 {
18420 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
18421 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES });
18422 vn_encode_VkPhysicalDeviceVulkan12Properties_pnext_partial(enc, val->pNext);
18423 vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(enc, val);
18424 }
18425
18426 /* struct VkPhysicalDeviceVulkan13Properties chain */
18427
18428 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Properties_pnext(const void * val)18429 vn_sizeof_VkPhysicalDeviceVulkan13Properties_pnext(const void *val)
18430 {
18431 /* no known/supported struct */
18432 return vn_sizeof_simple_pointer(NULL);
18433 }
18434
18435 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Properties_self(const VkPhysicalDeviceVulkan13Properties * val)18436 vn_sizeof_VkPhysicalDeviceVulkan13Properties_self(const VkPhysicalDeviceVulkan13Properties *val)
18437 {
18438 size_t size = 0;
18439 /* skip val->{sType,pNext} */
18440 size += vn_sizeof_uint32_t(&val->minSubgroupSize);
18441 size += vn_sizeof_uint32_t(&val->maxSubgroupSize);
18442 size += vn_sizeof_uint32_t(&val->maxComputeWorkgroupSubgroups);
18443 size += vn_sizeof_VkFlags(&val->requiredSubgroupSizeStages);
18444 size += vn_sizeof_uint32_t(&val->maxInlineUniformBlockSize);
18445 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorInlineUniformBlocks);
18446 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks);
18447 size += vn_sizeof_uint32_t(&val->maxDescriptorSetInlineUniformBlocks);
18448 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks);
18449 size += vn_sizeof_uint32_t(&val->maxInlineUniformTotalSize);
18450 size += vn_sizeof_VkBool32(&val->integerDotProduct8BitUnsignedAccelerated);
18451 size += vn_sizeof_VkBool32(&val->integerDotProduct8BitSignedAccelerated);
18452 size += vn_sizeof_VkBool32(&val->integerDotProduct8BitMixedSignednessAccelerated);
18453 size += vn_sizeof_VkBool32(&val->integerDotProduct4x8BitPackedUnsignedAccelerated);
18454 size += vn_sizeof_VkBool32(&val->integerDotProduct4x8BitPackedSignedAccelerated);
18455 size += vn_sizeof_VkBool32(&val->integerDotProduct4x8BitPackedMixedSignednessAccelerated);
18456 size += vn_sizeof_VkBool32(&val->integerDotProduct16BitUnsignedAccelerated);
18457 size += vn_sizeof_VkBool32(&val->integerDotProduct16BitSignedAccelerated);
18458 size += vn_sizeof_VkBool32(&val->integerDotProduct16BitMixedSignednessAccelerated);
18459 size += vn_sizeof_VkBool32(&val->integerDotProduct32BitUnsignedAccelerated);
18460 size += vn_sizeof_VkBool32(&val->integerDotProduct32BitSignedAccelerated);
18461 size += vn_sizeof_VkBool32(&val->integerDotProduct32BitMixedSignednessAccelerated);
18462 size += vn_sizeof_VkBool32(&val->integerDotProduct64BitUnsignedAccelerated);
18463 size += vn_sizeof_VkBool32(&val->integerDotProduct64BitSignedAccelerated);
18464 size += vn_sizeof_VkBool32(&val->integerDotProduct64BitMixedSignednessAccelerated);
18465 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated);
18466 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating8BitSignedAccelerated);
18467 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated);
18468 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated);
18469 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated);
18470 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated);
18471 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated);
18472 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating16BitSignedAccelerated);
18473 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated);
18474 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated);
18475 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating32BitSignedAccelerated);
18476 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated);
18477 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated);
18478 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating64BitSignedAccelerated);
18479 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated);
18480 size += vn_sizeof_VkDeviceSize(&val->storageTexelBufferOffsetAlignmentBytes);
18481 size += vn_sizeof_VkBool32(&val->storageTexelBufferOffsetSingleTexelAlignment);
18482 size += vn_sizeof_VkDeviceSize(&val->uniformTexelBufferOffsetAlignmentBytes);
18483 size += vn_sizeof_VkBool32(&val->uniformTexelBufferOffsetSingleTexelAlignment);
18484 size += vn_sizeof_VkDeviceSize(&val->maxBufferSize);
18485 return size;
18486 }
18487
18488 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Properties(const VkPhysicalDeviceVulkan13Properties * val)18489 vn_sizeof_VkPhysicalDeviceVulkan13Properties(const VkPhysicalDeviceVulkan13Properties *val)
18490 {
18491 size_t size = 0;
18492
18493 size += vn_sizeof_VkStructureType(&val->sType);
18494 size += vn_sizeof_VkPhysicalDeviceVulkan13Properties_pnext(val->pNext);
18495 size += vn_sizeof_VkPhysicalDeviceVulkan13Properties_self(val);
18496
18497 return size;
18498 }
18499
18500 static inline void
vn_decode_VkPhysicalDeviceVulkan13Properties_pnext(struct vn_cs_decoder * dec,const void * val)18501 vn_decode_VkPhysicalDeviceVulkan13Properties_pnext(struct vn_cs_decoder *dec, const void *val)
18502 {
18503 /* no known/supported struct */
18504 if (vn_decode_simple_pointer(dec))
18505 assert(false);
18506 }
18507
18508 static inline void
vn_decode_VkPhysicalDeviceVulkan13Properties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan13Properties * val)18509 vn_decode_VkPhysicalDeviceVulkan13Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan13Properties *val)
18510 {
18511 /* skip val->{sType,pNext} */
18512 vn_decode_uint32_t(dec, &val->minSubgroupSize);
18513 vn_decode_uint32_t(dec, &val->maxSubgroupSize);
18514 vn_decode_uint32_t(dec, &val->maxComputeWorkgroupSubgroups);
18515 vn_decode_VkFlags(dec, &val->requiredSubgroupSizeStages);
18516 vn_decode_uint32_t(dec, &val->maxInlineUniformBlockSize);
18517 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorInlineUniformBlocks);
18518 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks);
18519 vn_decode_uint32_t(dec, &val->maxDescriptorSetInlineUniformBlocks);
18520 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks);
18521 vn_decode_uint32_t(dec, &val->maxInlineUniformTotalSize);
18522 vn_decode_VkBool32(dec, &val->integerDotProduct8BitUnsignedAccelerated);
18523 vn_decode_VkBool32(dec, &val->integerDotProduct8BitSignedAccelerated);
18524 vn_decode_VkBool32(dec, &val->integerDotProduct8BitMixedSignednessAccelerated);
18525 vn_decode_VkBool32(dec, &val->integerDotProduct4x8BitPackedUnsignedAccelerated);
18526 vn_decode_VkBool32(dec, &val->integerDotProduct4x8BitPackedSignedAccelerated);
18527 vn_decode_VkBool32(dec, &val->integerDotProduct4x8BitPackedMixedSignednessAccelerated);
18528 vn_decode_VkBool32(dec, &val->integerDotProduct16BitUnsignedAccelerated);
18529 vn_decode_VkBool32(dec, &val->integerDotProduct16BitSignedAccelerated);
18530 vn_decode_VkBool32(dec, &val->integerDotProduct16BitMixedSignednessAccelerated);
18531 vn_decode_VkBool32(dec, &val->integerDotProduct32BitUnsignedAccelerated);
18532 vn_decode_VkBool32(dec, &val->integerDotProduct32BitSignedAccelerated);
18533 vn_decode_VkBool32(dec, &val->integerDotProduct32BitMixedSignednessAccelerated);
18534 vn_decode_VkBool32(dec, &val->integerDotProduct64BitUnsignedAccelerated);
18535 vn_decode_VkBool32(dec, &val->integerDotProduct64BitSignedAccelerated);
18536 vn_decode_VkBool32(dec, &val->integerDotProduct64BitMixedSignednessAccelerated);
18537 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated);
18538 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating8BitSignedAccelerated);
18539 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated);
18540 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated);
18541 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated);
18542 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated);
18543 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated);
18544 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating16BitSignedAccelerated);
18545 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated);
18546 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated);
18547 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating32BitSignedAccelerated);
18548 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated);
18549 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated);
18550 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating64BitSignedAccelerated);
18551 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated);
18552 vn_decode_VkDeviceSize(dec, &val->storageTexelBufferOffsetAlignmentBytes);
18553 vn_decode_VkBool32(dec, &val->storageTexelBufferOffsetSingleTexelAlignment);
18554 vn_decode_VkDeviceSize(dec, &val->uniformTexelBufferOffsetAlignmentBytes);
18555 vn_decode_VkBool32(dec, &val->uniformTexelBufferOffsetSingleTexelAlignment);
18556 vn_decode_VkDeviceSize(dec, &val->maxBufferSize);
18557 }
18558
18559 static inline void
vn_decode_VkPhysicalDeviceVulkan13Properties(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan13Properties * val)18560 vn_decode_VkPhysicalDeviceVulkan13Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan13Properties *val)
18561 {
18562 VkStructureType stype;
18563 vn_decode_VkStructureType(dec, &stype);
18564 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES);
18565
18566 assert(val->sType == stype);
18567 vn_decode_VkPhysicalDeviceVulkan13Properties_pnext(dec, val->pNext);
18568 vn_decode_VkPhysicalDeviceVulkan13Properties_self(dec, val);
18569 }
18570
18571 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Properties_pnext_partial(const void * val)18572 vn_sizeof_VkPhysicalDeviceVulkan13Properties_pnext_partial(const void *val)
18573 {
18574 /* no known/supported struct */
18575 return vn_sizeof_simple_pointer(NULL);
18576 }
18577
18578 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Properties_self_partial(const VkPhysicalDeviceVulkan13Properties * val)18579 vn_sizeof_VkPhysicalDeviceVulkan13Properties_self_partial(const VkPhysicalDeviceVulkan13Properties *val)
18580 {
18581 size_t size = 0;
18582 /* skip val->{sType,pNext} */
18583 /* skip val->minSubgroupSize */
18584 /* skip val->maxSubgroupSize */
18585 /* skip val->maxComputeWorkgroupSubgroups */
18586 /* skip val->requiredSubgroupSizeStages */
18587 /* skip val->maxInlineUniformBlockSize */
18588 /* skip val->maxPerStageDescriptorInlineUniformBlocks */
18589 /* skip val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks */
18590 /* skip val->maxDescriptorSetInlineUniformBlocks */
18591 /* skip val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks */
18592 /* skip val->maxInlineUniformTotalSize */
18593 /* skip val->integerDotProduct8BitUnsignedAccelerated */
18594 /* skip val->integerDotProduct8BitSignedAccelerated */
18595 /* skip val->integerDotProduct8BitMixedSignednessAccelerated */
18596 /* skip val->integerDotProduct4x8BitPackedUnsignedAccelerated */
18597 /* skip val->integerDotProduct4x8BitPackedSignedAccelerated */
18598 /* skip val->integerDotProduct4x8BitPackedMixedSignednessAccelerated */
18599 /* skip val->integerDotProduct16BitUnsignedAccelerated */
18600 /* skip val->integerDotProduct16BitSignedAccelerated */
18601 /* skip val->integerDotProduct16BitMixedSignednessAccelerated */
18602 /* skip val->integerDotProduct32BitUnsignedAccelerated */
18603 /* skip val->integerDotProduct32BitSignedAccelerated */
18604 /* skip val->integerDotProduct32BitMixedSignednessAccelerated */
18605 /* skip val->integerDotProduct64BitUnsignedAccelerated */
18606 /* skip val->integerDotProduct64BitSignedAccelerated */
18607 /* skip val->integerDotProduct64BitMixedSignednessAccelerated */
18608 /* skip val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated */
18609 /* skip val->integerDotProductAccumulatingSaturating8BitSignedAccelerated */
18610 /* skip val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated */
18611 /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated */
18612 /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated */
18613 /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated */
18614 /* skip val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated */
18615 /* skip val->integerDotProductAccumulatingSaturating16BitSignedAccelerated */
18616 /* skip val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated */
18617 /* skip val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated */
18618 /* skip val->integerDotProductAccumulatingSaturating32BitSignedAccelerated */
18619 /* skip val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated */
18620 /* skip val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated */
18621 /* skip val->integerDotProductAccumulatingSaturating64BitSignedAccelerated */
18622 /* skip val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated */
18623 /* skip val->storageTexelBufferOffsetAlignmentBytes */
18624 /* skip val->storageTexelBufferOffsetSingleTexelAlignment */
18625 /* skip val->uniformTexelBufferOffsetAlignmentBytes */
18626 /* skip val->uniformTexelBufferOffsetSingleTexelAlignment */
18627 /* skip val->maxBufferSize */
18628 return size;
18629 }
18630
18631 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Properties_partial(const VkPhysicalDeviceVulkan13Properties * val)18632 vn_sizeof_VkPhysicalDeviceVulkan13Properties_partial(const VkPhysicalDeviceVulkan13Properties *val)
18633 {
18634 size_t size = 0;
18635
18636 size += vn_sizeof_VkStructureType(&val->sType);
18637 size += vn_sizeof_VkPhysicalDeviceVulkan13Properties_pnext_partial(val->pNext);
18638 size += vn_sizeof_VkPhysicalDeviceVulkan13Properties_self_partial(val);
18639
18640 return size;
18641 }
18642
18643 static inline void
vn_encode_VkPhysicalDeviceVulkan13Properties_pnext_partial(struct vn_cs_encoder * enc,const void * val)18644 vn_encode_VkPhysicalDeviceVulkan13Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
18645 {
18646 /* no known/supported struct */
18647 vn_encode_simple_pointer(enc, NULL);
18648 }
18649
18650 static inline void
vn_encode_VkPhysicalDeviceVulkan13Properties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan13Properties * val)18651 vn_encode_VkPhysicalDeviceVulkan13Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan13Properties *val)
18652 {
18653 /* skip val->{sType,pNext} */
18654 /* skip val->minSubgroupSize */
18655 /* skip val->maxSubgroupSize */
18656 /* skip val->maxComputeWorkgroupSubgroups */
18657 /* skip val->requiredSubgroupSizeStages */
18658 /* skip val->maxInlineUniformBlockSize */
18659 /* skip val->maxPerStageDescriptorInlineUniformBlocks */
18660 /* skip val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks */
18661 /* skip val->maxDescriptorSetInlineUniformBlocks */
18662 /* skip val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks */
18663 /* skip val->maxInlineUniformTotalSize */
18664 /* skip val->integerDotProduct8BitUnsignedAccelerated */
18665 /* skip val->integerDotProduct8BitSignedAccelerated */
18666 /* skip val->integerDotProduct8BitMixedSignednessAccelerated */
18667 /* skip val->integerDotProduct4x8BitPackedUnsignedAccelerated */
18668 /* skip val->integerDotProduct4x8BitPackedSignedAccelerated */
18669 /* skip val->integerDotProduct4x8BitPackedMixedSignednessAccelerated */
18670 /* skip val->integerDotProduct16BitUnsignedAccelerated */
18671 /* skip val->integerDotProduct16BitSignedAccelerated */
18672 /* skip val->integerDotProduct16BitMixedSignednessAccelerated */
18673 /* skip val->integerDotProduct32BitUnsignedAccelerated */
18674 /* skip val->integerDotProduct32BitSignedAccelerated */
18675 /* skip val->integerDotProduct32BitMixedSignednessAccelerated */
18676 /* skip val->integerDotProduct64BitUnsignedAccelerated */
18677 /* skip val->integerDotProduct64BitSignedAccelerated */
18678 /* skip val->integerDotProduct64BitMixedSignednessAccelerated */
18679 /* skip val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated */
18680 /* skip val->integerDotProductAccumulatingSaturating8BitSignedAccelerated */
18681 /* skip val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated */
18682 /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated */
18683 /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated */
18684 /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated */
18685 /* skip val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated */
18686 /* skip val->integerDotProductAccumulatingSaturating16BitSignedAccelerated */
18687 /* skip val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated */
18688 /* skip val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated */
18689 /* skip val->integerDotProductAccumulatingSaturating32BitSignedAccelerated */
18690 /* skip val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated */
18691 /* skip val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated */
18692 /* skip val->integerDotProductAccumulatingSaturating64BitSignedAccelerated */
18693 /* skip val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated */
18694 /* skip val->storageTexelBufferOffsetAlignmentBytes */
18695 /* skip val->storageTexelBufferOffsetSingleTexelAlignment */
18696 /* skip val->uniformTexelBufferOffsetAlignmentBytes */
18697 /* skip val->uniformTexelBufferOffsetSingleTexelAlignment */
18698 /* skip val->maxBufferSize */
18699 }
18700
18701 static inline void
vn_encode_VkPhysicalDeviceVulkan13Properties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan13Properties * val)18702 vn_encode_VkPhysicalDeviceVulkan13Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan13Properties *val)
18703 {
18704 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES);
18705 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES });
18706 vn_encode_VkPhysicalDeviceVulkan13Properties_pnext_partial(enc, val->pNext);
18707 vn_encode_VkPhysicalDeviceVulkan13Properties_self_partial(enc, val);
18708 }
18709
18710 /* struct VkPhysicalDeviceCustomBorderColorPropertiesEXT chain */
18711
18712 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext(const void * val)18713 vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext(const void *val)
18714 {
18715 /* no known/supported struct */
18716 return vn_sizeof_simple_pointer(NULL);
18717 }
18718
18719 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self(const VkPhysicalDeviceCustomBorderColorPropertiesEXT * val)18720 vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self(const VkPhysicalDeviceCustomBorderColorPropertiesEXT *val)
18721 {
18722 size_t size = 0;
18723 /* skip val->{sType,pNext} */
18724 size += vn_sizeof_uint32_t(&val->maxCustomBorderColorSamplers);
18725 return size;
18726 }
18727
18728 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const VkPhysicalDeviceCustomBorderColorPropertiesEXT * val)18729 vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const VkPhysicalDeviceCustomBorderColorPropertiesEXT *val)
18730 {
18731 size_t size = 0;
18732
18733 size += vn_sizeof_VkStructureType(&val->sType);
18734 size += vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext(val->pNext);
18735 size += vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self(val);
18736
18737 return size;
18738 }
18739
18740 static inline void
vn_decode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)18741 vn_decode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
18742 {
18743 /* no known/supported struct */
18744 if (vn_decode_simple_pointer(dec))
18745 assert(false);
18746 }
18747
18748 static inline void
vn_decode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceCustomBorderColorPropertiesEXT * val)18749 vn_decode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceCustomBorderColorPropertiesEXT *val)
18750 {
18751 /* skip val->{sType,pNext} */
18752 vn_decode_uint32_t(dec, &val->maxCustomBorderColorSamplers);
18753 }
18754
18755 static inline void
vn_decode_VkPhysicalDeviceCustomBorderColorPropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceCustomBorderColorPropertiesEXT * val)18756 vn_decode_VkPhysicalDeviceCustomBorderColorPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceCustomBorderColorPropertiesEXT *val)
18757 {
18758 VkStructureType stype;
18759 vn_decode_VkStructureType(dec, &stype);
18760 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT);
18761
18762 assert(val->sType == stype);
18763 vn_decode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext(dec, val->pNext);
18764 vn_decode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self(dec, val);
18765 }
18766
18767 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext_partial(const void * val)18768 vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext_partial(const void *val)
18769 {
18770 /* no known/supported struct */
18771 return vn_sizeof_simple_pointer(NULL);
18772 }
18773
18774 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self_partial(const VkPhysicalDeviceCustomBorderColorPropertiesEXT * val)18775 vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self_partial(const VkPhysicalDeviceCustomBorderColorPropertiesEXT *val)
18776 {
18777 size_t size = 0;
18778 /* skip val->{sType,pNext} */
18779 /* skip val->maxCustomBorderColorSamplers */
18780 return size;
18781 }
18782
18783 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_partial(const VkPhysicalDeviceCustomBorderColorPropertiesEXT * val)18784 vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_partial(const VkPhysicalDeviceCustomBorderColorPropertiesEXT *val)
18785 {
18786 size_t size = 0;
18787
18788 size += vn_sizeof_VkStructureType(&val->sType);
18789 size += vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext_partial(val->pNext);
18790 size += vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self_partial(val);
18791
18792 return size;
18793 }
18794
18795 static inline void
vn_encode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)18796 vn_encode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
18797 {
18798 /* no known/supported struct */
18799 vn_encode_simple_pointer(enc, NULL);
18800 }
18801
18802 static inline void
vn_encode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceCustomBorderColorPropertiesEXT * val)18803 vn_encode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceCustomBorderColorPropertiesEXT *val)
18804 {
18805 /* skip val->{sType,pNext} */
18806 /* skip val->maxCustomBorderColorSamplers */
18807 }
18808
18809 static inline void
vn_encode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceCustomBorderColorPropertiesEXT * val)18810 vn_encode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceCustomBorderColorPropertiesEXT *val)
18811 {
18812 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT);
18813 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT });
18814 vn_encode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext_partial(enc, val->pNext);
18815 vn_encode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self_partial(enc, val);
18816 }
18817
18818 /* struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT chain */
18819
18820 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_pnext(const void * val)18821 vn_sizeof_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_pnext(const void *val)
18822 {
18823 /* no known/supported struct */
18824 return vn_sizeof_simple_pointer(NULL);
18825 }
18826
18827 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_self(const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT * val)18828 vn_sizeof_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_self(const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *val)
18829 {
18830 size_t size = 0;
18831 /* skip val->{sType,pNext} */
18832 size += vn_sizeof_VkBool32(&val->dynamicPrimitiveTopologyUnrestricted);
18833 return size;
18834 }
18835
18836 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT * val)18837 vn_sizeof_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *val)
18838 {
18839 size_t size = 0;
18840
18841 size += vn_sizeof_VkStructureType(&val->sType);
18842 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_pnext(val->pNext);
18843 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_self(val);
18844
18845 return size;
18846 }
18847
18848 static inline void
vn_decode_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)18849 vn_decode_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
18850 {
18851 /* no known/supported struct */
18852 if (vn_decode_simple_pointer(dec))
18853 assert(false);
18854 }
18855
18856 static inline void
vn_decode_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceExtendedDynamicState3PropertiesEXT * val)18857 vn_decode_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *val)
18858 {
18859 /* skip val->{sType,pNext} */
18860 vn_decode_VkBool32(dec, &val->dynamicPrimitiveTopologyUnrestricted);
18861 }
18862
18863 static inline void
vn_decode_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceExtendedDynamicState3PropertiesEXT * val)18864 vn_decode_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *val)
18865 {
18866 VkStructureType stype;
18867 vn_decode_VkStructureType(dec, &stype);
18868 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT);
18869
18870 assert(val->sType == stype);
18871 vn_decode_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_pnext(dec, val->pNext);
18872 vn_decode_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_self(dec, val);
18873 }
18874
18875 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_pnext_partial(const void * val)18876 vn_sizeof_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_pnext_partial(const void *val)
18877 {
18878 /* no known/supported struct */
18879 return vn_sizeof_simple_pointer(NULL);
18880 }
18881
18882 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_self_partial(const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT * val)18883 vn_sizeof_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_self_partial(const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *val)
18884 {
18885 size_t size = 0;
18886 /* skip val->{sType,pNext} */
18887 /* skip val->dynamicPrimitiveTopologyUnrestricted */
18888 return size;
18889 }
18890
18891 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_partial(const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT * val)18892 vn_sizeof_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_partial(const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *val)
18893 {
18894 size_t size = 0;
18895
18896 size += vn_sizeof_VkStructureType(&val->sType);
18897 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_pnext_partial(val->pNext);
18898 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_self_partial(val);
18899
18900 return size;
18901 }
18902
18903 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)18904 vn_encode_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
18905 {
18906 /* no known/supported struct */
18907 vn_encode_simple_pointer(enc, NULL);
18908 }
18909
18910 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT * val)18911 vn_encode_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *val)
18912 {
18913 /* skip val->{sType,pNext} */
18914 /* skip val->dynamicPrimitiveTopologyUnrestricted */
18915 }
18916
18917 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT * val)18918 vn_encode_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *val)
18919 {
18920 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT);
18921 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT });
18922 vn_encode_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_pnext_partial(enc, val->pNext);
18923 vn_encode_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_self_partial(enc, val);
18924 }
18925
18926 /* struct VkPhysicalDeviceRobustness2PropertiesEXT chain */
18927
18928 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_pnext(const void * val)18929 vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_pnext(const void *val)
18930 {
18931 /* no known/supported struct */
18932 return vn_sizeof_simple_pointer(NULL);
18933 }
18934
18935 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_self(const VkPhysicalDeviceRobustness2PropertiesEXT * val)18936 vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_self(const VkPhysicalDeviceRobustness2PropertiesEXT *val)
18937 {
18938 size_t size = 0;
18939 /* skip val->{sType,pNext} */
18940 size += vn_sizeof_VkDeviceSize(&val->robustStorageBufferAccessSizeAlignment);
18941 size += vn_sizeof_VkDeviceSize(&val->robustUniformBufferAccessSizeAlignment);
18942 return size;
18943 }
18944
18945 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT(const VkPhysicalDeviceRobustness2PropertiesEXT * val)18946 vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT(const VkPhysicalDeviceRobustness2PropertiesEXT *val)
18947 {
18948 size_t size = 0;
18949
18950 size += vn_sizeof_VkStructureType(&val->sType);
18951 size += vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_pnext(val->pNext);
18952 size += vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_self(val);
18953
18954 return size;
18955 }
18956
18957 static inline void
vn_decode_VkPhysicalDeviceRobustness2PropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)18958 vn_decode_VkPhysicalDeviceRobustness2PropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
18959 {
18960 /* no known/supported struct */
18961 if (vn_decode_simple_pointer(dec))
18962 assert(false);
18963 }
18964
18965 static inline void
vn_decode_VkPhysicalDeviceRobustness2PropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceRobustness2PropertiesEXT * val)18966 vn_decode_VkPhysicalDeviceRobustness2PropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceRobustness2PropertiesEXT *val)
18967 {
18968 /* skip val->{sType,pNext} */
18969 vn_decode_VkDeviceSize(dec, &val->robustStorageBufferAccessSizeAlignment);
18970 vn_decode_VkDeviceSize(dec, &val->robustUniformBufferAccessSizeAlignment);
18971 }
18972
18973 static inline void
vn_decode_VkPhysicalDeviceRobustness2PropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceRobustness2PropertiesEXT * val)18974 vn_decode_VkPhysicalDeviceRobustness2PropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceRobustness2PropertiesEXT *val)
18975 {
18976 VkStructureType stype;
18977 vn_decode_VkStructureType(dec, &stype);
18978 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT);
18979
18980 assert(val->sType == stype);
18981 vn_decode_VkPhysicalDeviceRobustness2PropertiesEXT_pnext(dec, val->pNext);
18982 vn_decode_VkPhysicalDeviceRobustness2PropertiesEXT_self(dec, val);
18983 }
18984
18985 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_pnext_partial(const void * val)18986 vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_pnext_partial(const void *val)
18987 {
18988 /* no known/supported struct */
18989 return vn_sizeof_simple_pointer(NULL);
18990 }
18991
18992 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_self_partial(const VkPhysicalDeviceRobustness2PropertiesEXT * val)18993 vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_self_partial(const VkPhysicalDeviceRobustness2PropertiesEXT *val)
18994 {
18995 size_t size = 0;
18996 /* skip val->{sType,pNext} */
18997 /* skip val->robustStorageBufferAccessSizeAlignment */
18998 /* skip val->robustUniformBufferAccessSizeAlignment */
18999 return size;
19000 }
19001
19002 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_partial(const VkPhysicalDeviceRobustness2PropertiesEXT * val)19003 vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_partial(const VkPhysicalDeviceRobustness2PropertiesEXT *val)
19004 {
19005 size_t size = 0;
19006
19007 size += vn_sizeof_VkStructureType(&val->sType);
19008 size += vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_pnext_partial(val->pNext);
19009 size += vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_self_partial(val);
19010
19011 return size;
19012 }
19013
19014 static inline void
vn_encode_VkPhysicalDeviceRobustness2PropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)19015 vn_encode_VkPhysicalDeviceRobustness2PropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
19016 {
19017 /* no known/supported struct */
19018 vn_encode_simple_pointer(enc, NULL);
19019 }
19020
19021 static inline void
vn_encode_VkPhysicalDeviceRobustness2PropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceRobustness2PropertiesEXT * val)19022 vn_encode_VkPhysicalDeviceRobustness2PropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceRobustness2PropertiesEXT *val)
19023 {
19024 /* skip val->{sType,pNext} */
19025 /* skip val->robustStorageBufferAccessSizeAlignment */
19026 /* skip val->robustUniformBufferAccessSizeAlignment */
19027 }
19028
19029 static inline void
vn_encode_VkPhysicalDeviceRobustness2PropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceRobustness2PropertiesEXT * val)19030 vn_encode_VkPhysicalDeviceRobustness2PropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceRobustness2PropertiesEXT *val)
19031 {
19032 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT);
19033 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT });
19034 vn_encode_VkPhysicalDeviceRobustness2PropertiesEXT_pnext_partial(enc, val->pNext);
19035 vn_encode_VkPhysicalDeviceRobustness2PropertiesEXT_self_partial(enc, val);
19036 }
19037
19038 /* struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR chain */
19039
19040 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_pnext(const void * val)19041 vn_sizeof_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_pnext(const void *val)
19042 {
19043 /* no known/supported struct */
19044 return vn_sizeof_simple_pointer(NULL);
19045 }
19046
19047 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_self(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR * val)19048 vn_sizeof_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_self(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *val)
19049 {
19050 size_t size = 0;
19051 /* skip val->{sType,pNext} */
19052 size += vn_sizeof_VkExtent2D(&val->minFragmentShadingRateAttachmentTexelSize);
19053 size += vn_sizeof_VkExtent2D(&val->maxFragmentShadingRateAttachmentTexelSize);
19054 size += vn_sizeof_uint32_t(&val->maxFragmentShadingRateAttachmentTexelSizeAspectRatio);
19055 size += vn_sizeof_VkBool32(&val->primitiveFragmentShadingRateWithMultipleViewports);
19056 size += vn_sizeof_VkBool32(&val->layeredShadingRateAttachments);
19057 size += vn_sizeof_VkBool32(&val->fragmentShadingRateNonTrivialCombinerOps);
19058 size += vn_sizeof_VkExtent2D(&val->maxFragmentSize);
19059 size += vn_sizeof_uint32_t(&val->maxFragmentSizeAspectRatio);
19060 size += vn_sizeof_uint32_t(&val->maxFragmentShadingRateCoverageSamples);
19061 size += vn_sizeof_VkSampleCountFlagBits(&val->maxFragmentShadingRateRasterizationSamples);
19062 size += vn_sizeof_VkBool32(&val->fragmentShadingRateWithShaderDepthStencilWrites);
19063 size += vn_sizeof_VkBool32(&val->fragmentShadingRateWithSampleMask);
19064 size += vn_sizeof_VkBool32(&val->fragmentShadingRateWithShaderSampleMask);
19065 size += vn_sizeof_VkBool32(&val->fragmentShadingRateWithConservativeRasterization);
19066 size += vn_sizeof_VkBool32(&val->fragmentShadingRateWithFragmentShaderInterlock);
19067 size += vn_sizeof_VkBool32(&val->fragmentShadingRateWithCustomSampleLocations);
19068 size += vn_sizeof_VkBool32(&val->fragmentShadingRateStrictMultiplyCombiner);
19069 return size;
19070 }
19071
19072 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR * val)19073 vn_sizeof_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *val)
19074 {
19075 size_t size = 0;
19076
19077 size += vn_sizeof_VkStructureType(&val->sType);
19078 size += vn_sizeof_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_pnext(val->pNext);
19079 size += vn_sizeof_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_self(val);
19080
19081 return size;
19082 }
19083
19084 static inline void
vn_decode_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_pnext(struct vn_cs_decoder * dec,const void * val)19085 vn_decode_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_pnext(struct vn_cs_decoder *dec, const void *val)
19086 {
19087 /* no known/supported struct */
19088 if (vn_decode_simple_pointer(dec))
19089 assert(false);
19090 }
19091
19092 static inline void
vn_decode_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_self(struct vn_cs_decoder * dec,VkPhysicalDeviceFragmentShadingRatePropertiesKHR * val)19093 vn_decode_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_self(struct vn_cs_decoder *dec, VkPhysicalDeviceFragmentShadingRatePropertiesKHR *val)
19094 {
19095 /* skip val->{sType,pNext} */
19096 vn_decode_VkExtent2D(dec, &val->minFragmentShadingRateAttachmentTexelSize);
19097 vn_decode_VkExtent2D(dec, &val->maxFragmentShadingRateAttachmentTexelSize);
19098 vn_decode_uint32_t(dec, &val->maxFragmentShadingRateAttachmentTexelSizeAspectRatio);
19099 vn_decode_VkBool32(dec, &val->primitiveFragmentShadingRateWithMultipleViewports);
19100 vn_decode_VkBool32(dec, &val->layeredShadingRateAttachments);
19101 vn_decode_VkBool32(dec, &val->fragmentShadingRateNonTrivialCombinerOps);
19102 vn_decode_VkExtent2D(dec, &val->maxFragmentSize);
19103 vn_decode_uint32_t(dec, &val->maxFragmentSizeAspectRatio);
19104 vn_decode_uint32_t(dec, &val->maxFragmentShadingRateCoverageSamples);
19105 vn_decode_VkSampleCountFlagBits(dec, &val->maxFragmentShadingRateRasterizationSamples);
19106 vn_decode_VkBool32(dec, &val->fragmentShadingRateWithShaderDepthStencilWrites);
19107 vn_decode_VkBool32(dec, &val->fragmentShadingRateWithSampleMask);
19108 vn_decode_VkBool32(dec, &val->fragmentShadingRateWithShaderSampleMask);
19109 vn_decode_VkBool32(dec, &val->fragmentShadingRateWithConservativeRasterization);
19110 vn_decode_VkBool32(dec, &val->fragmentShadingRateWithFragmentShaderInterlock);
19111 vn_decode_VkBool32(dec, &val->fragmentShadingRateWithCustomSampleLocations);
19112 vn_decode_VkBool32(dec, &val->fragmentShadingRateStrictMultiplyCombiner);
19113 }
19114
19115 static inline void
vn_decode_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(struct vn_cs_decoder * dec,VkPhysicalDeviceFragmentShadingRatePropertiesKHR * val)19116 vn_decode_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(struct vn_cs_decoder *dec, VkPhysicalDeviceFragmentShadingRatePropertiesKHR *val)
19117 {
19118 VkStructureType stype;
19119 vn_decode_VkStructureType(dec, &stype);
19120 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR);
19121
19122 assert(val->sType == stype);
19123 vn_decode_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_pnext(dec, val->pNext);
19124 vn_decode_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_self(dec, val);
19125 }
19126
19127 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_pnext_partial(const void * val)19128 vn_sizeof_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_pnext_partial(const void *val)
19129 {
19130 /* no known/supported struct */
19131 return vn_sizeof_simple_pointer(NULL);
19132 }
19133
19134 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_self_partial(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR * val)19135 vn_sizeof_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_self_partial(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *val)
19136 {
19137 size_t size = 0;
19138 /* skip val->{sType,pNext} */
19139 size += vn_sizeof_VkExtent2D_partial(&val->minFragmentShadingRateAttachmentTexelSize);
19140 size += vn_sizeof_VkExtent2D_partial(&val->maxFragmentShadingRateAttachmentTexelSize);
19141 /* skip val->maxFragmentShadingRateAttachmentTexelSizeAspectRatio */
19142 /* skip val->primitiveFragmentShadingRateWithMultipleViewports */
19143 /* skip val->layeredShadingRateAttachments */
19144 /* skip val->fragmentShadingRateNonTrivialCombinerOps */
19145 size += vn_sizeof_VkExtent2D_partial(&val->maxFragmentSize);
19146 /* skip val->maxFragmentSizeAspectRatio */
19147 /* skip val->maxFragmentShadingRateCoverageSamples */
19148 /* skip val->maxFragmentShadingRateRasterizationSamples */
19149 /* skip val->fragmentShadingRateWithShaderDepthStencilWrites */
19150 /* skip val->fragmentShadingRateWithSampleMask */
19151 /* skip val->fragmentShadingRateWithShaderSampleMask */
19152 /* skip val->fragmentShadingRateWithConservativeRasterization */
19153 /* skip val->fragmentShadingRateWithFragmentShaderInterlock */
19154 /* skip val->fragmentShadingRateWithCustomSampleLocations */
19155 /* skip val->fragmentShadingRateStrictMultiplyCombiner */
19156 return size;
19157 }
19158
19159 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_partial(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR * val)19160 vn_sizeof_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_partial(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *val)
19161 {
19162 size_t size = 0;
19163
19164 size += vn_sizeof_VkStructureType(&val->sType);
19165 size += vn_sizeof_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_pnext_partial(val->pNext);
19166 size += vn_sizeof_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_self_partial(val);
19167
19168 return size;
19169 }
19170
19171 static inline void
vn_encode_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_pnext_partial(struct vn_cs_encoder * enc,const void * val)19172 vn_encode_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_pnext_partial(struct vn_cs_encoder *enc, const void *val)
19173 {
19174 /* no known/supported struct */
19175 vn_encode_simple_pointer(enc, NULL);
19176 }
19177
19178 static inline void
vn_encode_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFragmentShadingRatePropertiesKHR * val)19179 vn_encode_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *val)
19180 {
19181 /* skip val->{sType,pNext} */
19182 vn_encode_VkExtent2D_partial(enc, &val->minFragmentShadingRateAttachmentTexelSize);
19183 vn_encode_VkExtent2D_partial(enc, &val->maxFragmentShadingRateAttachmentTexelSize);
19184 /* skip val->maxFragmentShadingRateAttachmentTexelSizeAspectRatio */
19185 /* skip val->primitiveFragmentShadingRateWithMultipleViewports */
19186 /* skip val->layeredShadingRateAttachments */
19187 /* skip val->fragmentShadingRateNonTrivialCombinerOps */
19188 vn_encode_VkExtent2D_partial(enc, &val->maxFragmentSize);
19189 /* skip val->maxFragmentSizeAspectRatio */
19190 /* skip val->maxFragmentShadingRateCoverageSamples */
19191 /* skip val->maxFragmentShadingRateRasterizationSamples */
19192 /* skip val->fragmentShadingRateWithShaderDepthStencilWrites */
19193 /* skip val->fragmentShadingRateWithSampleMask */
19194 /* skip val->fragmentShadingRateWithShaderSampleMask */
19195 /* skip val->fragmentShadingRateWithConservativeRasterization */
19196 /* skip val->fragmentShadingRateWithFragmentShaderInterlock */
19197 /* skip val->fragmentShadingRateWithCustomSampleLocations */
19198 /* skip val->fragmentShadingRateStrictMultiplyCombiner */
19199 }
19200
19201 static inline void
vn_encode_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFragmentShadingRatePropertiesKHR * val)19202 vn_encode_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *val)
19203 {
19204 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR);
19205 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR });
19206 vn_encode_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_pnext_partial(enc, val->pNext);
19207 vn_encode_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_self_partial(enc, val);
19208 }
19209
19210 /* struct VkPhysicalDeviceProvokingVertexPropertiesEXT chain */
19211
19212 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext(const void * val)19213 vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext(const void *val)
19214 {
19215 /* no known/supported struct */
19216 return vn_sizeof_simple_pointer(NULL);
19217 }
19218
19219 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_self(const VkPhysicalDeviceProvokingVertexPropertiesEXT * val)19220 vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_self(const VkPhysicalDeviceProvokingVertexPropertiesEXT *val)
19221 {
19222 size_t size = 0;
19223 /* skip val->{sType,pNext} */
19224 size += vn_sizeof_VkBool32(&val->provokingVertexModePerPipeline);
19225 size += vn_sizeof_VkBool32(&val->transformFeedbackPreservesTriangleFanProvokingVertex);
19226 return size;
19227 }
19228
19229 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT(const VkPhysicalDeviceProvokingVertexPropertiesEXT * val)19230 vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT(const VkPhysicalDeviceProvokingVertexPropertiesEXT *val)
19231 {
19232 size_t size = 0;
19233
19234 size += vn_sizeof_VkStructureType(&val->sType);
19235 size += vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext(val->pNext);
19236 size += vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_self(val);
19237
19238 return size;
19239 }
19240
19241 static inline void
vn_decode_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)19242 vn_decode_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
19243 {
19244 /* no known/supported struct */
19245 if (vn_decode_simple_pointer(dec))
19246 assert(false);
19247 }
19248
19249 static inline void
vn_decode_VkPhysicalDeviceProvokingVertexPropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceProvokingVertexPropertiesEXT * val)19250 vn_decode_VkPhysicalDeviceProvokingVertexPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProvokingVertexPropertiesEXT *val)
19251 {
19252 /* skip val->{sType,pNext} */
19253 vn_decode_VkBool32(dec, &val->provokingVertexModePerPipeline);
19254 vn_decode_VkBool32(dec, &val->transformFeedbackPreservesTriangleFanProvokingVertex);
19255 }
19256
19257 static inline void
vn_decode_VkPhysicalDeviceProvokingVertexPropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceProvokingVertexPropertiesEXT * val)19258 vn_decode_VkPhysicalDeviceProvokingVertexPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceProvokingVertexPropertiesEXT *val)
19259 {
19260 VkStructureType stype;
19261 vn_decode_VkStructureType(dec, &stype);
19262 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT);
19263
19264 assert(val->sType == stype);
19265 vn_decode_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext(dec, val->pNext);
19266 vn_decode_VkPhysicalDeviceProvokingVertexPropertiesEXT_self(dec, val);
19267 }
19268
19269 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext_partial(const void * val)19270 vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext_partial(const void *val)
19271 {
19272 /* no known/supported struct */
19273 return vn_sizeof_simple_pointer(NULL);
19274 }
19275
19276 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_self_partial(const VkPhysicalDeviceProvokingVertexPropertiesEXT * val)19277 vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_self_partial(const VkPhysicalDeviceProvokingVertexPropertiesEXT *val)
19278 {
19279 size_t size = 0;
19280 /* skip val->{sType,pNext} */
19281 /* skip val->provokingVertexModePerPipeline */
19282 /* skip val->transformFeedbackPreservesTriangleFanProvokingVertex */
19283 return size;
19284 }
19285
19286 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_partial(const VkPhysicalDeviceProvokingVertexPropertiesEXT * val)19287 vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_partial(const VkPhysicalDeviceProvokingVertexPropertiesEXT *val)
19288 {
19289 size_t size = 0;
19290
19291 size += vn_sizeof_VkStructureType(&val->sType);
19292 size += vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext_partial(val->pNext);
19293 size += vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_self_partial(val);
19294
19295 return size;
19296 }
19297
19298 static inline void
vn_encode_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)19299 vn_encode_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
19300 {
19301 /* no known/supported struct */
19302 vn_encode_simple_pointer(enc, NULL);
19303 }
19304
19305 static inline void
vn_encode_VkPhysicalDeviceProvokingVertexPropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProvokingVertexPropertiesEXT * val)19306 vn_encode_VkPhysicalDeviceProvokingVertexPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProvokingVertexPropertiesEXT *val)
19307 {
19308 /* skip val->{sType,pNext} */
19309 /* skip val->provokingVertexModePerPipeline */
19310 /* skip val->transformFeedbackPreservesTriangleFanProvokingVertex */
19311 }
19312
19313 static inline void
vn_encode_VkPhysicalDeviceProvokingVertexPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProvokingVertexPropertiesEXT * val)19314 vn_encode_VkPhysicalDeviceProvokingVertexPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProvokingVertexPropertiesEXT *val)
19315 {
19316 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT);
19317 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT });
19318 vn_encode_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext_partial(enc, val->pNext);
19319 vn_encode_VkPhysicalDeviceProvokingVertexPropertiesEXT_self_partial(enc, val);
19320 }
19321
19322 /* struct VkPhysicalDeviceShaderIntegerDotProductProperties chain */
19323
19324 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext(const void * val)19325 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext(const void *val)
19326 {
19327 /* no known/supported struct */
19328 return vn_sizeof_simple_pointer(NULL);
19329 }
19330
19331 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self(const VkPhysicalDeviceShaderIntegerDotProductProperties * val)19332 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self(const VkPhysicalDeviceShaderIntegerDotProductProperties *val)
19333 {
19334 size_t size = 0;
19335 /* skip val->{sType,pNext} */
19336 size += vn_sizeof_VkBool32(&val->integerDotProduct8BitUnsignedAccelerated);
19337 size += vn_sizeof_VkBool32(&val->integerDotProduct8BitSignedAccelerated);
19338 size += vn_sizeof_VkBool32(&val->integerDotProduct8BitMixedSignednessAccelerated);
19339 size += vn_sizeof_VkBool32(&val->integerDotProduct4x8BitPackedUnsignedAccelerated);
19340 size += vn_sizeof_VkBool32(&val->integerDotProduct4x8BitPackedSignedAccelerated);
19341 size += vn_sizeof_VkBool32(&val->integerDotProduct4x8BitPackedMixedSignednessAccelerated);
19342 size += vn_sizeof_VkBool32(&val->integerDotProduct16BitUnsignedAccelerated);
19343 size += vn_sizeof_VkBool32(&val->integerDotProduct16BitSignedAccelerated);
19344 size += vn_sizeof_VkBool32(&val->integerDotProduct16BitMixedSignednessAccelerated);
19345 size += vn_sizeof_VkBool32(&val->integerDotProduct32BitUnsignedAccelerated);
19346 size += vn_sizeof_VkBool32(&val->integerDotProduct32BitSignedAccelerated);
19347 size += vn_sizeof_VkBool32(&val->integerDotProduct32BitMixedSignednessAccelerated);
19348 size += vn_sizeof_VkBool32(&val->integerDotProduct64BitUnsignedAccelerated);
19349 size += vn_sizeof_VkBool32(&val->integerDotProduct64BitSignedAccelerated);
19350 size += vn_sizeof_VkBool32(&val->integerDotProduct64BitMixedSignednessAccelerated);
19351 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated);
19352 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating8BitSignedAccelerated);
19353 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated);
19354 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated);
19355 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated);
19356 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated);
19357 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated);
19358 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating16BitSignedAccelerated);
19359 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated);
19360 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated);
19361 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating32BitSignedAccelerated);
19362 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated);
19363 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated);
19364 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating64BitSignedAccelerated);
19365 size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated);
19366 return size;
19367 }
19368
19369 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties(const VkPhysicalDeviceShaderIntegerDotProductProperties * val)19370 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties(const VkPhysicalDeviceShaderIntegerDotProductProperties *val)
19371 {
19372 size_t size = 0;
19373
19374 size += vn_sizeof_VkStructureType(&val->sType);
19375 size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext(val->pNext);
19376 size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self(val);
19377
19378 return size;
19379 }
19380
19381 static inline void
vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext(struct vn_cs_decoder * dec,const void * val)19382 vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext(struct vn_cs_decoder *dec, const void *val)
19383 {
19384 /* no known/supported struct */
19385 if (vn_decode_simple_pointer(dec))
19386 assert(false);
19387 }
19388
19389 static inline void
vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderIntegerDotProductProperties * val)19390 vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderIntegerDotProductProperties *val)
19391 {
19392 /* skip val->{sType,pNext} */
19393 vn_decode_VkBool32(dec, &val->integerDotProduct8BitUnsignedAccelerated);
19394 vn_decode_VkBool32(dec, &val->integerDotProduct8BitSignedAccelerated);
19395 vn_decode_VkBool32(dec, &val->integerDotProduct8BitMixedSignednessAccelerated);
19396 vn_decode_VkBool32(dec, &val->integerDotProduct4x8BitPackedUnsignedAccelerated);
19397 vn_decode_VkBool32(dec, &val->integerDotProduct4x8BitPackedSignedAccelerated);
19398 vn_decode_VkBool32(dec, &val->integerDotProduct4x8BitPackedMixedSignednessAccelerated);
19399 vn_decode_VkBool32(dec, &val->integerDotProduct16BitUnsignedAccelerated);
19400 vn_decode_VkBool32(dec, &val->integerDotProduct16BitSignedAccelerated);
19401 vn_decode_VkBool32(dec, &val->integerDotProduct16BitMixedSignednessAccelerated);
19402 vn_decode_VkBool32(dec, &val->integerDotProduct32BitUnsignedAccelerated);
19403 vn_decode_VkBool32(dec, &val->integerDotProduct32BitSignedAccelerated);
19404 vn_decode_VkBool32(dec, &val->integerDotProduct32BitMixedSignednessAccelerated);
19405 vn_decode_VkBool32(dec, &val->integerDotProduct64BitUnsignedAccelerated);
19406 vn_decode_VkBool32(dec, &val->integerDotProduct64BitSignedAccelerated);
19407 vn_decode_VkBool32(dec, &val->integerDotProduct64BitMixedSignednessAccelerated);
19408 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated);
19409 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating8BitSignedAccelerated);
19410 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated);
19411 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated);
19412 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated);
19413 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated);
19414 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated);
19415 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating16BitSignedAccelerated);
19416 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated);
19417 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated);
19418 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating32BitSignedAccelerated);
19419 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated);
19420 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated);
19421 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating64BitSignedAccelerated);
19422 vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated);
19423 }
19424
19425 static inline void
vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderIntegerDotProductProperties * val)19426 vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderIntegerDotProductProperties *val)
19427 {
19428 VkStructureType stype;
19429 vn_decode_VkStructureType(dec, &stype);
19430 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES);
19431
19432 assert(val->sType == stype);
19433 vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext(dec, val->pNext);
19434 vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties_self(dec, val);
19435 }
19436
19437 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext_partial(const void * val)19438 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext_partial(const void *val)
19439 {
19440 /* no known/supported struct */
19441 return vn_sizeof_simple_pointer(NULL);
19442 }
19443
19444 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial(const VkPhysicalDeviceShaderIntegerDotProductProperties * val)19445 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial(const VkPhysicalDeviceShaderIntegerDotProductProperties *val)
19446 {
19447 size_t size = 0;
19448 /* skip val->{sType,pNext} */
19449 /* skip val->integerDotProduct8BitUnsignedAccelerated */
19450 /* skip val->integerDotProduct8BitSignedAccelerated */
19451 /* skip val->integerDotProduct8BitMixedSignednessAccelerated */
19452 /* skip val->integerDotProduct4x8BitPackedUnsignedAccelerated */
19453 /* skip val->integerDotProduct4x8BitPackedSignedAccelerated */
19454 /* skip val->integerDotProduct4x8BitPackedMixedSignednessAccelerated */
19455 /* skip val->integerDotProduct16BitUnsignedAccelerated */
19456 /* skip val->integerDotProduct16BitSignedAccelerated */
19457 /* skip val->integerDotProduct16BitMixedSignednessAccelerated */
19458 /* skip val->integerDotProduct32BitUnsignedAccelerated */
19459 /* skip val->integerDotProduct32BitSignedAccelerated */
19460 /* skip val->integerDotProduct32BitMixedSignednessAccelerated */
19461 /* skip val->integerDotProduct64BitUnsignedAccelerated */
19462 /* skip val->integerDotProduct64BitSignedAccelerated */
19463 /* skip val->integerDotProduct64BitMixedSignednessAccelerated */
19464 /* skip val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated */
19465 /* skip val->integerDotProductAccumulatingSaturating8BitSignedAccelerated */
19466 /* skip val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated */
19467 /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated */
19468 /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated */
19469 /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated */
19470 /* skip val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated */
19471 /* skip val->integerDotProductAccumulatingSaturating16BitSignedAccelerated */
19472 /* skip val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated */
19473 /* skip val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated */
19474 /* skip val->integerDotProductAccumulatingSaturating32BitSignedAccelerated */
19475 /* skip val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated */
19476 /* skip val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated */
19477 /* skip val->integerDotProductAccumulatingSaturating64BitSignedAccelerated */
19478 /* skip val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated */
19479 return size;
19480 }
19481
19482 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_partial(const VkPhysicalDeviceShaderIntegerDotProductProperties * val)19483 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_partial(const VkPhysicalDeviceShaderIntegerDotProductProperties *val)
19484 {
19485 size_t size = 0;
19486
19487 size += vn_sizeof_VkStructureType(&val->sType);
19488 size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext_partial(val->pNext);
19489 size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial(val);
19490
19491 return size;
19492 }
19493
19494 static inline void
vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)19495 vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
19496 {
19497 /* no known/supported struct */
19498 vn_encode_simple_pointer(enc, NULL);
19499 }
19500
19501 static inline void
vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderIntegerDotProductProperties * val)19502 vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderIntegerDotProductProperties *val)
19503 {
19504 /* skip val->{sType,pNext} */
19505 /* skip val->integerDotProduct8BitUnsignedAccelerated */
19506 /* skip val->integerDotProduct8BitSignedAccelerated */
19507 /* skip val->integerDotProduct8BitMixedSignednessAccelerated */
19508 /* skip val->integerDotProduct4x8BitPackedUnsignedAccelerated */
19509 /* skip val->integerDotProduct4x8BitPackedSignedAccelerated */
19510 /* skip val->integerDotProduct4x8BitPackedMixedSignednessAccelerated */
19511 /* skip val->integerDotProduct16BitUnsignedAccelerated */
19512 /* skip val->integerDotProduct16BitSignedAccelerated */
19513 /* skip val->integerDotProduct16BitMixedSignednessAccelerated */
19514 /* skip val->integerDotProduct32BitUnsignedAccelerated */
19515 /* skip val->integerDotProduct32BitSignedAccelerated */
19516 /* skip val->integerDotProduct32BitMixedSignednessAccelerated */
19517 /* skip val->integerDotProduct64BitUnsignedAccelerated */
19518 /* skip val->integerDotProduct64BitSignedAccelerated */
19519 /* skip val->integerDotProduct64BitMixedSignednessAccelerated */
19520 /* skip val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated */
19521 /* skip val->integerDotProductAccumulatingSaturating8BitSignedAccelerated */
19522 /* skip val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated */
19523 /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated */
19524 /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated */
19525 /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated */
19526 /* skip val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated */
19527 /* skip val->integerDotProductAccumulatingSaturating16BitSignedAccelerated */
19528 /* skip val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated */
19529 /* skip val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated */
19530 /* skip val->integerDotProductAccumulatingSaturating32BitSignedAccelerated */
19531 /* skip val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated */
19532 /* skip val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated */
19533 /* skip val->integerDotProductAccumulatingSaturating64BitSignedAccelerated */
19534 /* skip val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated */
19535 }
19536
19537 static inline void
vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderIntegerDotProductProperties * val)19538 vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderIntegerDotProductProperties *val)
19539 {
19540 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES);
19541 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES });
19542 vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext_partial(enc, val->pNext);
19543 vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial(enc, val);
19544 }
19545
19546 /* struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT chain */
19547
19548 static inline size_t
vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_pnext(const void * val)19549 vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_pnext(const void *val)
19550 {
19551 /* no known/supported struct */
19552 return vn_sizeof_simple_pointer(NULL);
19553 }
19554
19555 static inline size_t
vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_self(const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT * val)19556 vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_self(const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *val)
19557 {
19558 size_t size = 0;
19559 /* skip val->{sType,pNext} */
19560 size += vn_sizeof_VkBool32(&val->graphicsPipelineLibraryFastLinking);
19561 size += vn_sizeof_VkBool32(&val->graphicsPipelineLibraryIndependentInterpolationDecoration);
19562 return size;
19563 }
19564
19565 static inline size_t
vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT * val)19566 vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *val)
19567 {
19568 size_t size = 0;
19569
19570 size += vn_sizeof_VkStructureType(&val->sType);
19571 size += vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_pnext(val->pNext);
19572 size += vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_self(val);
19573
19574 return size;
19575 }
19576
19577 static inline void
vn_decode_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)19578 vn_decode_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
19579 {
19580 /* no known/supported struct */
19581 if (vn_decode_simple_pointer(dec))
19582 assert(false);
19583 }
19584
19585 static inline void
vn_decode_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT * val)19586 vn_decode_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *val)
19587 {
19588 /* skip val->{sType,pNext} */
19589 vn_decode_VkBool32(dec, &val->graphicsPipelineLibraryFastLinking);
19590 vn_decode_VkBool32(dec, &val->graphicsPipelineLibraryIndependentInterpolationDecoration);
19591 }
19592
19593 static inline void
vn_decode_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT * val)19594 vn_decode_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *val)
19595 {
19596 VkStructureType stype;
19597 vn_decode_VkStructureType(dec, &stype);
19598 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT);
19599
19600 assert(val->sType == stype);
19601 vn_decode_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_pnext(dec, val->pNext);
19602 vn_decode_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_self(dec, val);
19603 }
19604
19605 static inline size_t
vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_pnext_partial(const void * val)19606 vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_pnext_partial(const void *val)
19607 {
19608 /* no known/supported struct */
19609 return vn_sizeof_simple_pointer(NULL);
19610 }
19611
19612 static inline size_t
vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_self_partial(const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT * val)19613 vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_self_partial(const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *val)
19614 {
19615 size_t size = 0;
19616 /* skip val->{sType,pNext} */
19617 /* skip val->graphicsPipelineLibraryFastLinking */
19618 /* skip val->graphicsPipelineLibraryIndependentInterpolationDecoration */
19619 return size;
19620 }
19621
19622 static inline size_t
vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_partial(const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT * val)19623 vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_partial(const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *val)
19624 {
19625 size_t size = 0;
19626
19627 size += vn_sizeof_VkStructureType(&val->sType);
19628 size += vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_pnext_partial(val->pNext);
19629 size += vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_self_partial(val);
19630
19631 return size;
19632 }
19633
19634 static inline void
vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)19635 vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
19636 {
19637 /* no known/supported struct */
19638 vn_encode_simple_pointer(enc, NULL);
19639 }
19640
19641 static inline void
vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT * val)19642 vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *val)
19643 {
19644 /* skip val->{sType,pNext} */
19645 /* skip val->graphicsPipelineLibraryFastLinking */
19646 /* skip val->graphicsPipelineLibraryIndependentInterpolationDecoration */
19647 }
19648
19649 static inline void
vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT * val)19650 vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *val)
19651 {
19652 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT);
19653 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT });
19654 vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_pnext_partial(enc, val->pNext);
19655 vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_self_partial(enc, val);
19656 }
19657
19658 /* struct VkPhysicalDeviceProperties2 chain */
19659
19660 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_pnext(const void * val)19661 vn_sizeof_VkPhysicalDeviceProperties2_pnext(const void *val)
19662 {
19663 const VkBaseInStructure *pnext = val;
19664 size_t size = 0;
19665
19666 while (pnext) {
19667 switch ((int32_t)pnext->sType) {
19668 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
19669 if (!vn_cs_renderer_protocol_has_extension(393 /* VK_EXT_multi_draw */))
19670 break;
19671 size += vn_sizeof_simple_pointer(pnext);
19672 size += vn_sizeof_VkStructureType(&pnext->sType);
19673 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19674 size += vn_sizeof_VkPhysicalDeviceMultiDrawPropertiesEXT_self((const VkPhysicalDeviceMultiDrawPropertiesEXT *)pnext);
19675 return size;
19676 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
19677 if (!vn_cs_renderer_protocol_has_extension(81 /* VK_KHR_push_descriptor */))
19678 break;
19679 size += vn_sizeof_simple_pointer(pnext);
19680 size += vn_sizeof_VkStructureType(&pnext->sType);
19681 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19682 size += vn_sizeof_VkPhysicalDevicePushDescriptorPropertiesKHR_self((const VkPhysicalDevicePushDescriptorPropertiesKHR *)pnext);
19683 return size;
19684 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
19685 size += vn_sizeof_simple_pointer(pnext);
19686 size += vn_sizeof_VkStructureType(&pnext->sType);
19687 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19688 size += vn_sizeof_VkPhysicalDeviceDriverProperties_self((const VkPhysicalDeviceDriverProperties *)pnext);
19689 return size;
19690 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
19691 size += vn_sizeof_simple_pointer(pnext);
19692 size += vn_sizeof_VkStructureType(&pnext->sType);
19693 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19694 size += vn_sizeof_VkPhysicalDeviceIDProperties_self((const VkPhysicalDeviceIDProperties *)pnext);
19695 return size;
19696 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
19697 size += vn_sizeof_simple_pointer(pnext);
19698 size += vn_sizeof_VkStructureType(&pnext->sType);
19699 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19700 size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self((const VkPhysicalDeviceMultiviewProperties *)pnext);
19701 return size;
19702 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
19703 size += vn_sizeof_simple_pointer(pnext);
19704 size += vn_sizeof_VkStructureType(&pnext->sType);
19705 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19706 size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self((const VkPhysicalDeviceSubgroupProperties *)pnext);
19707 return size;
19708 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
19709 size += vn_sizeof_simple_pointer(pnext);
19710 size += vn_sizeof_VkStructureType(&pnext->sType);
19711 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19712 size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self((const VkPhysicalDevicePointClippingProperties *)pnext);
19713 return size;
19714 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
19715 size += vn_sizeof_simple_pointer(pnext);
19716 size += vn_sizeof_VkStructureType(&pnext->sType);
19717 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19718 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self((const VkPhysicalDeviceProtectedMemoryProperties *)pnext);
19719 return size;
19720 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
19721 size += vn_sizeof_simple_pointer(pnext);
19722 size += vn_sizeof_VkStructureType(&pnext->sType);
19723 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19724 size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self((const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
19725 return size;
19726 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
19727 if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
19728 break;
19729 size += vn_sizeof_simple_pointer(pnext);
19730 size += vn_sizeof_VkStructureType(&pnext->sType);
19731 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19732 size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self((const VkPhysicalDeviceInlineUniformBlockProperties *)pnext);
19733 return size;
19734 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
19735 size += vn_sizeof_simple_pointer(pnext);
19736 size += vn_sizeof_VkStructureType(&pnext->sType);
19737 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19738 size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self((const VkPhysicalDeviceMaintenance3Properties *)pnext);
19739 return size;
19740 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
19741 if (!vn_cs_renderer_protocol_has_extension(414 /* VK_KHR_maintenance4 */))
19742 break;
19743 size += vn_sizeof_simple_pointer(pnext);
19744 size += vn_sizeof_VkStructureType(&pnext->sType);
19745 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19746 size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self((const VkPhysicalDeviceMaintenance4Properties *)pnext);
19747 return size;
19748 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR:
19749 if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
19750 break;
19751 size += vn_sizeof_simple_pointer(pnext);
19752 size += vn_sizeof_VkStructureType(&pnext->sType);
19753 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19754 size += vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_self((const VkPhysicalDeviceMaintenance5PropertiesKHR *)pnext);
19755 return size;
19756 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
19757 size += vn_sizeof_simple_pointer(pnext);
19758 size += vn_sizeof_VkStructureType(&pnext->sType);
19759 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19760 size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self((const VkPhysicalDeviceFloatControlsProperties *)pnext);
19761 return size;
19762 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
19763 if (!vn_cs_renderer_protocol_has_extension(102 /* VK_EXT_conservative_rasterization */))
19764 break;
19765 size += vn_sizeof_simple_pointer(pnext);
19766 size += vn_sizeof_VkStructureType(&pnext->sType);
19767 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19768 size += vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self((const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)pnext);
19769 return size;
19770 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
19771 size += vn_sizeof_simple_pointer(pnext);
19772 size += vn_sizeof_VkStructureType(&pnext->sType);
19773 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19774 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self((const VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
19775 return size;
19776 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
19777 size += vn_sizeof_simple_pointer(pnext);
19778 size += vn_sizeof_VkStructureType(&pnext->sType);
19779 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19780 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self((const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
19781 return size;
19782 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
19783 if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
19784 break;
19785 size += vn_sizeof_simple_pointer(pnext);
19786 size += vn_sizeof_VkStructureType(&pnext->sType);
19787 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19788 size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self((const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)pnext);
19789 return size;
19790 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
19791 if (!vn_cs_renderer_protocol_has_extension(213 /* VK_EXT_pci_bus_info */))
19792 break;
19793 size += vn_sizeof_simple_pointer(pnext);
19794 size += vn_sizeof_VkStructureType(&pnext->sType);
19795 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19796 size += vn_sizeof_VkPhysicalDevicePCIBusInfoPropertiesEXT_self((const VkPhysicalDevicePCIBusInfoPropertiesEXT *)pnext);
19797 return size;
19798 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
19799 size += vn_sizeof_simple_pointer(pnext);
19800 size += vn_sizeof_VkStructureType(&pnext->sType);
19801 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19802 size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self((const VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
19803 return size;
19804 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
19805 if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
19806 break;
19807 size += vn_sizeof_simple_pointer(pnext);
19808 size += vn_sizeof_VkStructureType(&pnext->sType);
19809 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19810 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self((const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
19811 return size;
19812 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
19813 if (!vn_cs_renderer_protocol_has_extension(282 /* VK_EXT_texel_buffer_alignment */))
19814 break;
19815 size += vn_sizeof_simple_pointer(pnext);
19816 size += vn_sizeof_VkStructureType(&pnext->sType);
19817 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19818 size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self((const VkPhysicalDeviceTexelBufferAlignmentProperties *)pnext);
19819 return size;
19820 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
19821 if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
19822 break;
19823 size += vn_sizeof_simple_pointer(pnext);
19824 size += vn_sizeof_VkStructureType(&pnext->sType);
19825 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19826 size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self((const VkPhysicalDeviceSubgroupSizeControlProperties *)pnext);
19827 return size;
19828 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
19829 if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
19830 break;
19831 size += vn_sizeof_simple_pointer(pnext);
19832 size += vn_sizeof_VkStructureType(&pnext->sType);
19833 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19834 size += vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_self((const VkPhysicalDeviceLineRasterizationPropertiesEXT *)pnext);
19835 return size;
19836 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
19837 size += vn_sizeof_simple_pointer(pnext);
19838 size += vn_sizeof_VkStructureType(&pnext->sType);
19839 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19840 size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self((const VkPhysicalDeviceVulkan11Properties *)pnext);
19841 return size;
19842 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
19843 size += vn_sizeof_simple_pointer(pnext);
19844 size += vn_sizeof_VkStructureType(&pnext->sType);
19845 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19846 size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self((const VkPhysicalDeviceVulkan12Properties *)pnext);
19847 return size;
19848 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
19849 if (!vn_cs_renderer_protocol_has_api_version(VK_API_VERSION_1_3))
19850 break;
19851 size += vn_sizeof_simple_pointer(pnext);
19852 size += vn_sizeof_VkStructureType(&pnext->sType);
19853 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19854 size += vn_sizeof_VkPhysicalDeviceVulkan13Properties_self((const VkPhysicalDeviceVulkan13Properties *)pnext);
19855 return size;
19856 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
19857 if (!vn_cs_renderer_protocol_has_extension(288 /* VK_EXT_custom_border_color */))
19858 break;
19859 size += vn_sizeof_simple_pointer(pnext);
19860 size += vn_sizeof_VkStructureType(&pnext->sType);
19861 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19862 size += vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self((const VkPhysicalDeviceCustomBorderColorPropertiesEXT *)pnext);
19863 return size;
19864 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
19865 if (!vn_cs_renderer_protocol_has_extension(456 /* VK_EXT_extended_dynamic_state3 */))
19866 break;
19867 size += vn_sizeof_simple_pointer(pnext);
19868 size += vn_sizeof_VkStructureType(&pnext->sType);
19869 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19870 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_self((const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *)pnext);
19871 return size;
19872 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
19873 if (!vn_cs_renderer_protocol_has_extension(287 /* VK_EXT_robustness2 */))
19874 break;
19875 size += vn_sizeof_simple_pointer(pnext);
19876 size += vn_sizeof_VkStructureType(&pnext->sType);
19877 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19878 size += vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_self((const VkPhysicalDeviceRobustness2PropertiesEXT *)pnext);
19879 return size;
19880 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
19881 if (!vn_cs_renderer_protocol_has_extension(227 /* VK_KHR_fragment_shading_rate */))
19882 break;
19883 size += vn_sizeof_simple_pointer(pnext);
19884 size += vn_sizeof_VkStructureType(&pnext->sType);
19885 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19886 size += vn_sizeof_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_self((const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)pnext);
19887 return size;
19888 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
19889 if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
19890 break;
19891 size += vn_sizeof_simple_pointer(pnext);
19892 size += vn_sizeof_VkStructureType(&pnext->sType);
19893 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19894 size += vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_self((const VkPhysicalDeviceProvokingVertexPropertiesEXT *)pnext);
19895 return size;
19896 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
19897 if (!vn_cs_renderer_protocol_has_extension(281 /* VK_KHR_shader_integer_dot_product */))
19898 break;
19899 size += vn_sizeof_simple_pointer(pnext);
19900 size += vn_sizeof_VkStructureType(&pnext->sType);
19901 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19902 size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self((const VkPhysicalDeviceShaderIntegerDotProductProperties *)pnext);
19903 return size;
19904 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
19905 if (!vn_cs_renderer_protocol_has_extension(321 /* VK_EXT_graphics_pipeline_library */))
19906 break;
19907 size += vn_sizeof_simple_pointer(pnext);
19908 size += vn_sizeof_VkStructureType(&pnext->sType);
19909 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
19910 size += vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_self((const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *)pnext);
19911 return size;
19912 default:
19913 /* ignore unknown/unsupported struct */
19914 break;
19915 }
19916 pnext = pnext->pNext;
19917 }
19918
19919 return vn_sizeof_simple_pointer(NULL);
19920 }
19921
19922 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_self(const VkPhysicalDeviceProperties2 * val)19923 vn_sizeof_VkPhysicalDeviceProperties2_self(const VkPhysicalDeviceProperties2 *val)
19924 {
19925 size_t size = 0;
19926 /* skip val->{sType,pNext} */
19927 size += vn_sizeof_VkPhysicalDeviceProperties(&val->properties);
19928 return size;
19929 }
19930
19931 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2 * val)19932 vn_sizeof_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2 *val)
19933 {
19934 size_t size = 0;
19935
19936 size += vn_sizeof_VkStructureType(&val->sType);
19937 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(val->pNext);
19938 size += vn_sizeof_VkPhysicalDeviceProperties2_self(val);
19939
19940 return size;
19941 }
19942
19943 static inline void
vn_decode_VkPhysicalDeviceProperties2_pnext(struct vn_cs_decoder * dec,const void * val)19944 vn_decode_VkPhysicalDeviceProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
19945 {
19946 VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
19947 VkStructureType stype;
19948
19949 if (!vn_decode_simple_pointer(dec))
19950 return;
19951
19952 vn_decode_VkStructureType(dec, &stype);
19953 while (true) {
19954 assert(pnext);
19955 if (pnext->sType == stype)
19956 break;
19957
19958 pnext = pnext->pNext;
19959 }
19960
19961 switch ((int32_t)pnext->sType) {
19962 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
19963 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
19964 vn_decode_VkPhysicalDeviceMultiDrawPropertiesEXT_self(dec, (VkPhysicalDeviceMultiDrawPropertiesEXT *)pnext);
19965 break;
19966 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
19967 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
19968 vn_decode_VkPhysicalDevicePushDescriptorPropertiesKHR_self(dec, (VkPhysicalDevicePushDescriptorPropertiesKHR *)pnext);
19969 break;
19970 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
19971 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
19972 vn_decode_VkPhysicalDeviceDriverProperties_self(dec, (VkPhysicalDeviceDriverProperties *)pnext);
19973 break;
19974 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
19975 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
19976 vn_decode_VkPhysicalDeviceIDProperties_self(dec, (VkPhysicalDeviceIDProperties *)pnext);
19977 break;
19978 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
19979 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
19980 vn_decode_VkPhysicalDeviceMultiviewProperties_self(dec, (VkPhysicalDeviceMultiviewProperties *)pnext);
19981 break;
19982 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
19983 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
19984 vn_decode_VkPhysicalDeviceSubgroupProperties_self(dec, (VkPhysicalDeviceSubgroupProperties *)pnext);
19985 break;
19986 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
19987 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
19988 vn_decode_VkPhysicalDevicePointClippingProperties_self(dec, (VkPhysicalDevicePointClippingProperties *)pnext);
19989 break;
19990 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
19991 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
19992 vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(dec, (VkPhysicalDeviceProtectedMemoryProperties *)pnext);
19993 break;
19994 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
19995 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
19996 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(dec, (VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
19997 break;
19998 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
19999 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20000 vn_decode_VkPhysicalDeviceInlineUniformBlockProperties_self(dec, (VkPhysicalDeviceInlineUniformBlockProperties *)pnext);
20001 break;
20002 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
20003 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20004 vn_decode_VkPhysicalDeviceMaintenance3Properties_self(dec, (VkPhysicalDeviceMaintenance3Properties *)pnext);
20005 break;
20006 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
20007 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20008 vn_decode_VkPhysicalDeviceMaintenance4Properties_self(dec, (VkPhysicalDeviceMaintenance4Properties *)pnext);
20009 break;
20010 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR:
20011 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20012 vn_decode_VkPhysicalDeviceMaintenance5PropertiesKHR_self(dec, (VkPhysicalDeviceMaintenance5PropertiesKHR *)pnext);
20013 break;
20014 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
20015 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20016 vn_decode_VkPhysicalDeviceFloatControlsProperties_self(dec, (VkPhysicalDeviceFloatControlsProperties *)pnext);
20017 break;
20018 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
20019 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20020 vn_decode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self(dec, (VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)pnext);
20021 break;
20022 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
20023 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20024 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(dec, (VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
20025 break;
20026 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
20027 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20028 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(dec, (VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
20029 break;
20030 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
20031 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20032 vn_decode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self(dec, (VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)pnext);
20033 break;
20034 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
20035 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20036 vn_decode_VkPhysicalDevicePCIBusInfoPropertiesEXT_self(dec, (VkPhysicalDevicePCIBusInfoPropertiesEXT *)pnext);
20037 break;
20038 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
20039 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20040 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(dec, (VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
20041 break;
20042 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
20043 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20044 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(dec, (VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
20045 break;
20046 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
20047 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20048 vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties_self(dec, (VkPhysicalDeviceTexelBufferAlignmentProperties *)pnext);
20049 break;
20050 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
20051 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20052 vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties_self(dec, (VkPhysicalDeviceSubgroupSizeControlProperties *)pnext);
20053 break;
20054 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
20055 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20056 vn_decode_VkPhysicalDeviceLineRasterizationPropertiesEXT_self(dec, (VkPhysicalDeviceLineRasterizationPropertiesEXT *)pnext);
20057 break;
20058 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
20059 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20060 vn_decode_VkPhysicalDeviceVulkan11Properties_self(dec, (VkPhysicalDeviceVulkan11Properties *)pnext);
20061 break;
20062 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
20063 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20064 vn_decode_VkPhysicalDeviceVulkan12Properties_self(dec, (VkPhysicalDeviceVulkan12Properties *)pnext);
20065 break;
20066 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
20067 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20068 vn_decode_VkPhysicalDeviceVulkan13Properties_self(dec, (VkPhysicalDeviceVulkan13Properties *)pnext);
20069 break;
20070 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
20071 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20072 vn_decode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self(dec, (VkPhysicalDeviceCustomBorderColorPropertiesEXT *)pnext);
20073 break;
20074 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
20075 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20076 vn_decode_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_self(dec, (VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *)pnext);
20077 break;
20078 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
20079 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20080 vn_decode_VkPhysicalDeviceRobustness2PropertiesEXT_self(dec, (VkPhysicalDeviceRobustness2PropertiesEXT *)pnext);
20081 break;
20082 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
20083 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20084 vn_decode_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_self(dec, (VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)pnext);
20085 break;
20086 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
20087 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20088 vn_decode_VkPhysicalDeviceProvokingVertexPropertiesEXT_self(dec, (VkPhysicalDeviceProvokingVertexPropertiesEXT *)pnext);
20089 break;
20090 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
20091 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20092 vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties_self(dec, (VkPhysicalDeviceShaderIntegerDotProductProperties *)pnext);
20093 break;
20094 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
20095 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
20096 vn_decode_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_self(dec, (VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *)pnext);
20097 break;
20098 default:
20099 assert(false);
20100 break;
20101 }
20102 }
20103
20104 static inline void
vn_decode_VkPhysicalDeviceProperties2_self(struct vn_cs_decoder * dec,VkPhysicalDeviceProperties2 * val)20105 vn_decode_VkPhysicalDeviceProperties2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties2 *val)
20106 {
20107 /* skip val->{sType,pNext} */
20108 vn_decode_VkPhysicalDeviceProperties(dec, &val->properties);
20109 }
20110
20111 static inline void
vn_decode_VkPhysicalDeviceProperties2(struct vn_cs_decoder * dec,VkPhysicalDeviceProperties2 * val)20112 vn_decode_VkPhysicalDeviceProperties2(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties2 *val)
20113 {
20114 VkStructureType stype;
20115 vn_decode_VkStructureType(dec, &stype);
20116 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);
20117
20118 assert(val->sType == stype);
20119 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, val->pNext);
20120 vn_decode_VkPhysicalDeviceProperties2_self(dec, val);
20121 }
20122
20123 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(const void * val)20124 vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(const void *val)
20125 {
20126 const VkBaseInStructure *pnext = val;
20127 size_t size = 0;
20128
20129 while (pnext) {
20130 switch ((int32_t)pnext->sType) {
20131 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
20132 if (!vn_cs_renderer_protocol_has_extension(393 /* VK_EXT_multi_draw */))
20133 break;
20134 size += vn_sizeof_simple_pointer(pnext);
20135 size += vn_sizeof_VkStructureType(&pnext->sType);
20136 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20137 size += vn_sizeof_VkPhysicalDeviceMultiDrawPropertiesEXT_self_partial((const VkPhysicalDeviceMultiDrawPropertiesEXT *)pnext);
20138 return size;
20139 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
20140 if (!vn_cs_renderer_protocol_has_extension(81 /* VK_KHR_push_descriptor */))
20141 break;
20142 size += vn_sizeof_simple_pointer(pnext);
20143 size += vn_sizeof_VkStructureType(&pnext->sType);
20144 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20145 size += vn_sizeof_VkPhysicalDevicePushDescriptorPropertiesKHR_self_partial((const VkPhysicalDevicePushDescriptorPropertiesKHR *)pnext);
20146 return size;
20147 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
20148 size += vn_sizeof_simple_pointer(pnext);
20149 size += vn_sizeof_VkStructureType(&pnext->sType);
20150 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20151 size += vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial((const VkPhysicalDeviceDriverProperties *)pnext);
20152 return size;
20153 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
20154 size += vn_sizeof_simple_pointer(pnext);
20155 size += vn_sizeof_VkStructureType(&pnext->sType);
20156 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20157 size += vn_sizeof_VkPhysicalDeviceIDProperties_self_partial((const VkPhysicalDeviceIDProperties *)pnext);
20158 return size;
20159 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
20160 size += vn_sizeof_simple_pointer(pnext);
20161 size += vn_sizeof_VkStructureType(&pnext->sType);
20162 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20163 size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial((const VkPhysicalDeviceMultiviewProperties *)pnext);
20164 return size;
20165 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
20166 size += vn_sizeof_simple_pointer(pnext);
20167 size += vn_sizeof_VkStructureType(&pnext->sType);
20168 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20169 size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial((const VkPhysicalDeviceSubgroupProperties *)pnext);
20170 return size;
20171 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
20172 size += vn_sizeof_simple_pointer(pnext);
20173 size += vn_sizeof_VkStructureType(&pnext->sType);
20174 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20175 size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial((const VkPhysicalDevicePointClippingProperties *)pnext);
20176 return size;
20177 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
20178 size += vn_sizeof_simple_pointer(pnext);
20179 size += vn_sizeof_VkStructureType(&pnext->sType);
20180 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20181 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial((const VkPhysicalDeviceProtectedMemoryProperties *)pnext);
20182 return size;
20183 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
20184 size += vn_sizeof_simple_pointer(pnext);
20185 size += vn_sizeof_VkStructureType(&pnext->sType);
20186 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20187 size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial((const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
20188 return size;
20189 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
20190 if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
20191 break;
20192 size += vn_sizeof_simple_pointer(pnext);
20193 size += vn_sizeof_VkStructureType(&pnext->sType);
20194 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20195 size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self_partial((const VkPhysicalDeviceInlineUniformBlockProperties *)pnext);
20196 return size;
20197 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
20198 size += vn_sizeof_simple_pointer(pnext);
20199 size += vn_sizeof_VkStructureType(&pnext->sType);
20200 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20201 size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial((const VkPhysicalDeviceMaintenance3Properties *)pnext);
20202 return size;
20203 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
20204 if (!vn_cs_renderer_protocol_has_extension(414 /* VK_KHR_maintenance4 */))
20205 break;
20206 size += vn_sizeof_simple_pointer(pnext);
20207 size += vn_sizeof_VkStructureType(&pnext->sType);
20208 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20209 size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self_partial((const VkPhysicalDeviceMaintenance4Properties *)pnext);
20210 return size;
20211 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR:
20212 if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
20213 break;
20214 size += vn_sizeof_simple_pointer(pnext);
20215 size += vn_sizeof_VkStructureType(&pnext->sType);
20216 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20217 size += vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_self_partial((const VkPhysicalDeviceMaintenance5PropertiesKHR *)pnext);
20218 return size;
20219 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
20220 size += vn_sizeof_simple_pointer(pnext);
20221 size += vn_sizeof_VkStructureType(&pnext->sType);
20222 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20223 size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial((const VkPhysicalDeviceFloatControlsProperties *)pnext);
20224 return size;
20225 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
20226 if (!vn_cs_renderer_protocol_has_extension(102 /* VK_EXT_conservative_rasterization */))
20227 break;
20228 size += vn_sizeof_simple_pointer(pnext);
20229 size += vn_sizeof_VkStructureType(&pnext->sType);
20230 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20231 size += vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self_partial((const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)pnext);
20232 return size;
20233 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
20234 size += vn_sizeof_simple_pointer(pnext);
20235 size += vn_sizeof_VkStructureType(&pnext->sType);
20236 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20237 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial((const VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
20238 return size;
20239 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
20240 size += vn_sizeof_simple_pointer(pnext);
20241 size += vn_sizeof_VkStructureType(&pnext->sType);
20242 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20243 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial((const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
20244 return size;
20245 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
20246 if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
20247 break;
20248 size += vn_sizeof_simple_pointer(pnext);
20249 size += vn_sizeof_VkStructureType(&pnext->sType);
20250 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20251 size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self_partial((const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)pnext);
20252 return size;
20253 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
20254 if (!vn_cs_renderer_protocol_has_extension(213 /* VK_EXT_pci_bus_info */))
20255 break;
20256 size += vn_sizeof_simple_pointer(pnext);
20257 size += vn_sizeof_VkStructureType(&pnext->sType);
20258 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20259 size += vn_sizeof_VkPhysicalDevicePCIBusInfoPropertiesEXT_self_partial((const VkPhysicalDevicePCIBusInfoPropertiesEXT *)pnext);
20260 return size;
20261 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
20262 size += vn_sizeof_simple_pointer(pnext);
20263 size += vn_sizeof_VkStructureType(&pnext->sType);
20264 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20265 size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial((const VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
20266 return size;
20267 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
20268 if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
20269 break;
20270 size += vn_sizeof_simple_pointer(pnext);
20271 size += vn_sizeof_VkStructureType(&pnext->sType);
20272 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20273 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial((const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
20274 return size;
20275 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
20276 if (!vn_cs_renderer_protocol_has_extension(282 /* VK_EXT_texel_buffer_alignment */))
20277 break;
20278 size += vn_sizeof_simple_pointer(pnext);
20279 size += vn_sizeof_VkStructureType(&pnext->sType);
20280 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20281 size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial((const VkPhysicalDeviceTexelBufferAlignmentProperties *)pnext);
20282 return size;
20283 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
20284 if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
20285 break;
20286 size += vn_sizeof_simple_pointer(pnext);
20287 size += vn_sizeof_VkStructureType(&pnext->sType);
20288 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20289 size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial((const VkPhysicalDeviceSubgroupSizeControlProperties *)pnext);
20290 return size;
20291 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
20292 if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
20293 break;
20294 size += vn_sizeof_simple_pointer(pnext);
20295 size += vn_sizeof_VkStructureType(&pnext->sType);
20296 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20297 size += vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_self_partial((const VkPhysicalDeviceLineRasterizationPropertiesEXT *)pnext);
20298 return size;
20299 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
20300 size += vn_sizeof_simple_pointer(pnext);
20301 size += vn_sizeof_VkStructureType(&pnext->sType);
20302 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20303 size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial((const VkPhysicalDeviceVulkan11Properties *)pnext);
20304 return size;
20305 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
20306 size += vn_sizeof_simple_pointer(pnext);
20307 size += vn_sizeof_VkStructureType(&pnext->sType);
20308 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20309 size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial((const VkPhysicalDeviceVulkan12Properties *)pnext);
20310 return size;
20311 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
20312 if (!vn_cs_renderer_protocol_has_api_version(VK_API_VERSION_1_3))
20313 break;
20314 size += vn_sizeof_simple_pointer(pnext);
20315 size += vn_sizeof_VkStructureType(&pnext->sType);
20316 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20317 size += vn_sizeof_VkPhysicalDeviceVulkan13Properties_self_partial((const VkPhysicalDeviceVulkan13Properties *)pnext);
20318 return size;
20319 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
20320 if (!vn_cs_renderer_protocol_has_extension(288 /* VK_EXT_custom_border_color */))
20321 break;
20322 size += vn_sizeof_simple_pointer(pnext);
20323 size += vn_sizeof_VkStructureType(&pnext->sType);
20324 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20325 size += vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self_partial((const VkPhysicalDeviceCustomBorderColorPropertiesEXT *)pnext);
20326 return size;
20327 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
20328 if (!vn_cs_renderer_protocol_has_extension(456 /* VK_EXT_extended_dynamic_state3 */))
20329 break;
20330 size += vn_sizeof_simple_pointer(pnext);
20331 size += vn_sizeof_VkStructureType(&pnext->sType);
20332 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20333 size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_self_partial((const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *)pnext);
20334 return size;
20335 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
20336 if (!vn_cs_renderer_protocol_has_extension(287 /* VK_EXT_robustness2 */))
20337 break;
20338 size += vn_sizeof_simple_pointer(pnext);
20339 size += vn_sizeof_VkStructureType(&pnext->sType);
20340 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20341 size += vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_self_partial((const VkPhysicalDeviceRobustness2PropertiesEXT *)pnext);
20342 return size;
20343 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
20344 if (!vn_cs_renderer_protocol_has_extension(227 /* VK_KHR_fragment_shading_rate */))
20345 break;
20346 size += vn_sizeof_simple_pointer(pnext);
20347 size += vn_sizeof_VkStructureType(&pnext->sType);
20348 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20349 size += vn_sizeof_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_self_partial((const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)pnext);
20350 return size;
20351 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
20352 if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
20353 break;
20354 size += vn_sizeof_simple_pointer(pnext);
20355 size += vn_sizeof_VkStructureType(&pnext->sType);
20356 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20357 size += vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_self_partial((const VkPhysicalDeviceProvokingVertexPropertiesEXT *)pnext);
20358 return size;
20359 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
20360 if (!vn_cs_renderer_protocol_has_extension(281 /* VK_KHR_shader_integer_dot_product */))
20361 break;
20362 size += vn_sizeof_simple_pointer(pnext);
20363 size += vn_sizeof_VkStructureType(&pnext->sType);
20364 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20365 size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial((const VkPhysicalDeviceShaderIntegerDotProductProperties *)pnext);
20366 return size;
20367 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
20368 if (!vn_cs_renderer_protocol_has_extension(321 /* VK_EXT_graphics_pipeline_library */))
20369 break;
20370 size += vn_sizeof_simple_pointer(pnext);
20371 size += vn_sizeof_VkStructureType(&pnext->sType);
20372 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
20373 size += vn_sizeof_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_self_partial((const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *)pnext);
20374 return size;
20375 default:
20376 /* ignore unknown/unsupported struct */
20377 break;
20378 }
20379 pnext = pnext->pNext;
20380 }
20381
20382 return vn_sizeof_simple_pointer(NULL);
20383 }
20384
20385 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_self_partial(const VkPhysicalDeviceProperties2 * val)20386 vn_sizeof_VkPhysicalDeviceProperties2_self_partial(const VkPhysicalDeviceProperties2 *val)
20387 {
20388 size_t size = 0;
20389 /* skip val->{sType,pNext} */
20390 size += vn_sizeof_VkPhysicalDeviceProperties_partial(&val->properties);
20391 return size;
20392 }
20393
20394 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_partial(const VkPhysicalDeviceProperties2 * val)20395 vn_sizeof_VkPhysicalDeviceProperties2_partial(const VkPhysicalDeviceProperties2 *val)
20396 {
20397 size_t size = 0;
20398
20399 size += vn_sizeof_VkStructureType(&val->sType);
20400 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(val->pNext);
20401 size += vn_sizeof_VkPhysicalDeviceProperties2_self_partial(val);
20402
20403 return size;
20404 }
20405
20406 static inline void
vn_encode_VkPhysicalDeviceProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)20407 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
20408 {
20409 const VkBaseInStructure *pnext = val;
20410
20411 while (pnext) {
20412 switch ((int32_t)pnext->sType) {
20413 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
20414 if (!vn_cs_renderer_protocol_has_extension(393 /* VK_EXT_multi_draw */))
20415 break;
20416 vn_encode_simple_pointer(enc, pnext);
20417 vn_encode_VkStructureType(enc, &pnext->sType);
20418 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20419 vn_encode_VkPhysicalDeviceMultiDrawPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceMultiDrawPropertiesEXT *)pnext);
20420 return;
20421 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
20422 if (!vn_cs_renderer_protocol_has_extension(81 /* VK_KHR_push_descriptor */))
20423 break;
20424 vn_encode_simple_pointer(enc, pnext);
20425 vn_encode_VkStructureType(enc, &pnext->sType);
20426 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20427 vn_encode_VkPhysicalDevicePushDescriptorPropertiesKHR_self_partial(enc, (const VkPhysicalDevicePushDescriptorPropertiesKHR *)pnext);
20428 return;
20429 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
20430 vn_encode_simple_pointer(enc, pnext);
20431 vn_encode_VkStructureType(enc, &pnext->sType);
20432 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20433 vn_encode_VkPhysicalDeviceDriverProperties_self_partial(enc, (const VkPhysicalDeviceDriverProperties *)pnext);
20434 return;
20435 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
20436 vn_encode_simple_pointer(enc, pnext);
20437 vn_encode_VkStructureType(enc, &pnext->sType);
20438 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20439 vn_encode_VkPhysicalDeviceIDProperties_self_partial(enc, (const VkPhysicalDeviceIDProperties *)pnext);
20440 return;
20441 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
20442 vn_encode_simple_pointer(enc, pnext);
20443 vn_encode_VkStructureType(enc, &pnext->sType);
20444 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20445 vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(enc, (const VkPhysicalDeviceMultiviewProperties *)pnext);
20446 return;
20447 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
20448 vn_encode_simple_pointer(enc, pnext);
20449 vn_encode_VkStructureType(enc, &pnext->sType);
20450 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20451 vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(enc, (const VkPhysicalDeviceSubgroupProperties *)pnext);
20452 return;
20453 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
20454 vn_encode_simple_pointer(enc, pnext);
20455 vn_encode_VkStructureType(enc, &pnext->sType);
20456 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20457 vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(enc, (const VkPhysicalDevicePointClippingProperties *)pnext);
20458 return;
20459 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
20460 vn_encode_simple_pointer(enc, pnext);
20461 vn_encode_VkStructureType(enc, &pnext->sType);
20462 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20463 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(enc, (const VkPhysicalDeviceProtectedMemoryProperties *)pnext);
20464 return;
20465 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
20466 vn_encode_simple_pointer(enc, pnext);
20467 vn_encode_VkStructureType(enc, &pnext->sType);
20468 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20469 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(enc, (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
20470 return;
20471 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
20472 if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
20473 break;
20474 vn_encode_simple_pointer(enc, pnext);
20475 vn_encode_VkStructureType(enc, &pnext->sType);
20476 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20477 vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_self_partial(enc, (const VkPhysicalDeviceInlineUniformBlockProperties *)pnext);
20478 return;
20479 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
20480 vn_encode_simple_pointer(enc, pnext);
20481 vn_encode_VkStructureType(enc, &pnext->sType);
20482 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20483 vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(enc, (const VkPhysicalDeviceMaintenance3Properties *)pnext);
20484 return;
20485 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
20486 if (!vn_cs_renderer_protocol_has_extension(414 /* VK_KHR_maintenance4 */))
20487 break;
20488 vn_encode_simple_pointer(enc, pnext);
20489 vn_encode_VkStructureType(enc, &pnext->sType);
20490 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20491 vn_encode_VkPhysicalDeviceMaintenance4Properties_self_partial(enc, (const VkPhysicalDeviceMaintenance4Properties *)pnext);
20492 return;
20493 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR:
20494 if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
20495 break;
20496 vn_encode_simple_pointer(enc, pnext);
20497 vn_encode_VkStructureType(enc, &pnext->sType);
20498 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20499 vn_encode_VkPhysicalDeviceMaintenance5PropertiesKHR_self_partial(enc, (const VkPhysicalDeviceMaintenance5PropertiesKHR *)pnext);
20500 return;
20501 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
20502 vn_encode_simple_pointer(enc, pnext);
20503 vn_encode_VkStructureType(enc, &pnext->sType);
20504 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20505 vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(enc, (const VkPhysicalDeviceFloatControlsProperties *)pnext);
20506 return;
20507 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
20508 if (!vn_cs_renderer_protocol_has_extension(102 /* VK_EXT_conservative_rasterization */))
20509 break;
20510 vn_encode_simple_pointer(enc, pnext);
20511 vn_encode_VkStructureType(enc, &pnext->sType);
20512 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20513 vn_encode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)pnext);
20514 return;
20515 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
20516 vn_encode_simple_pointer(enc, pnext);
20517 vn_encode_VkStructureType(enc, &pnext->sType);
20518 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20519 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(enc, (const VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
20520 return;
20521 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
20522 vn_encode_simple_pointer(enc, pnext);
20523 vn_encode_VkStructureType(enc, &pnext->sType);
20524 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20525 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(enc, (const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
20526 return;
20527 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
20528 if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
20529 break;
20530 vn_encode_simple_pointer(enc, pnext);
20531 vn_encode_VkStructureType(enc, &pnext->sType);
20532 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20533 vn_encode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)pnext);
20534 return;
20535 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
20536 if (!vn_cs_renderer_protocol_has_extension(213 /* VK_EXT_pci_bus_info */))
20537 break;
20538 vn_encode_simple_pointer(enc, pnext);
20539 vn_encode_VkStructureType(enc, &pnext->sType);
20540 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20541 vn_encode_VkPhysicalDevicePCIBusInfoPropertiesEXT_self_partial(enc, (const VkPhysicalDevicePCIBusInfoPropertiesEXT *)pnext);
20542 return;
20543 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
20544 vn_encode_simple_pointer(enc, pnext);
20545 vn_encode_VkStructureType(enc, &pnext->sType);
20546 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20547 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(enc, (const VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
20548 return;
20549 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
20550 if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
20551 break;
20552 vn_encode_simple_pointer(enc, pnext);
20553 vn_encode_VkStructureType(enc, &pnext->sType);
20554 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20555 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
20556 return;
20557 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
20558 if (!vn_cs_renderer_protocol_has_extension(282 /* VK_EXT_texel_buffer_alignment */))
20559 break;
20560 vn_encode_simple_pointer(enc, pnext);
20561 vn_encode_VkStructureType(enc, &pnext->sType);
20562 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20563 vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial(enc, (const VkPhysicalDeviceTexelBufferAlignmentProperties *)pnext);
20564 return;
20565 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
20566 if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
20567 break;
20568 vn_encode_simple_pointer(enc, pnext);
20569 vn_encode_VkStructureType(enc, &pnext->sType);
20570 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20571 vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial(enc, (const VkPhysicalDeviceSubgroupSizeControlProperties *)pnext);
20572 return;
20573 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
20574 if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
20575 break;
20576 vn_encode_simple_pointer(enc, pnext);
20577 vn_encode_VkStructureType(enc, &pnext->sType);
20578 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20579 vn_encode_VkPhysicalDeviceLineRasterizationPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceLineRasterizationPropertiesEXT *)pnext);
20580 return;
20581 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
20582 vn_encode_simple_pointer(enc, pnext);
20583 vn_encode_VkStructureType(enc, &pnext->sType);
20584 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20585 vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(enc, (const VkPhysicalDeviceVulkan11Properties *)pnext);
20586 return;
20587 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
20588 vn_encode_simple_pointer(enc, pnext);
20589 vn_encode_VkStructureType(enc, &pnext->sType);
20590 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20591 vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(enc, (const VkPhysicalDeviceVulkan12Properties *)pnext);
20592 return;
20593 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
20594 if (!vn_cs_renderer_protocol_has_api_version(VK_API_VERSION_1_3))
20595 break;
20596 vn_encode_simple_pointer(enc, pnext);
20597 vn_encode_VkStructureType(enc, &pnext->sType);
20598 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20599 vn_encode_VkPhysicalDeviceVulkan13Properties_self_partial(enc, (const VkPhysicalDeviceVulkan13Properties *)pnext);
20600 return;
20601 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
20602 if (!vn_cs_renderer_protocol_has_extension(288 /* VK_EXT_custom_border_color */))
20603 break;
20604 vn_encode_simple_pointer(enc, pnext);
20605 vn_encode_VkStructureType(enc, &pnext->sType);
20606 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20607 vn_encode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceCustomBorderColorPropertiesEXT *)pnext);
20608 return;
20609 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
20610 if (!vn_cs_renderer_protocol_has_extension(456 /* VK_EXT_extended_dynamic_state3 */))
20611 break;
20612 vn_encode_simple_pointer(enc, pnext);
20613 vn_encode_VkStructureType(enc, &pnext->sType);
20614 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20615 vn_encode_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT_self_partial(enc, (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *)pnext);
20616 return;
20617 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
20618 if (!vn_cs_renderer_protocol_has_extension(287 /* VK_EXT_robustness2 */))
20619 break;
20620 vn_encode_simple_pointer(enc, pnext);
20621 vn_encode_VkStructureType(enc, &pnext->sType);
20622 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20623 vn_encode_VkPhysicalDeviceRobustness2PropertiesEXT_self_partial(enc, (const VkPhysicalDeviceRobustness2PropertiesEXT *)pnext);
20624 return;
20625 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
20626 if (!vn_cs_renderer_protocol_has_extension(227 /* VK_KHR_fragment_shading_rate */))
20627 break;
20628 vn_encode_simple_pointer(enc, pnext);
20629 vn_encode_VkStructureType(enc, &pnext->sType);
20630 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20631 vn_encode_VkPhysicalDeviceFragmentShadingRatePropertiesKHR_self_partial(enc, (const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)pnext);
20632 return;
20633 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
20634 if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
20635 break;
20636 vn_encode_simple_pointer(enc, pnext);
20637 vn_encode_VkStructureType(enc, &pnext->sType);
20638 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20639 vn_encode_VkPhysicalDeviceProvokingVertexPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceProvokingVertexPropertiesEXT *)pnext);
20640 return;
20641 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
20642 if (!vn_cs_renderer_protocol_has_extension(281 /* VK_KHR_shader_integer_dot_product */))
20643 break;
20644 vn_encode_simple_pointer(enc, pnext);
20645 vn_encode_VkStructureType(enc, &pnext->sType);
20646 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20647 vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial(enc, (const VkPhysicalDeviceShaderIntegerDotProductProperties *)pnext);
20648 return;
20649 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
20650 if (!vn_cs_renderer_protocol_has_extension(321 /* VK_EXT_graphics_pipeline_library */))
20651 break;
20652 vn_encode_simple_pointer(enc, pnext);
20653 vn_encode_VkStructureType(enc, &pnext->sType);
20654 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
20655 vn_encode_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *)pnext);
20656 return;
20657 default:
20658 /* ignore unknown/unsupported struct */
20659 break;
20660 }
20661 pnext = pnext->pNext;
20662 }
20663
20664 vn_encode_simple_pointer(enc, NULL);
20665 }
20666
20667 static inline void
vn_encode_VkPhysicalDeviceProperties2_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProperties2 * val)20668 vn_encode_VkPhysicalDeviceProperties2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties2 *val)
20669 {
20670 /* skip val->{sType,pNext} */
20671 vn_encode_VkPhysicalDeviceProperties_partial(enc, &val->properties);
20672 }
20673
20674 static inline void
vn_encode_VkPhysicalDeviceProperties2_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProperties2 * val)20675 vn_encode_VkPhysicalDeviceProperties2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties2 *val)
20676 {
20677 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);
20678 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 });
20679 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, val->pNext);
20680 vn_encode_VkPhysicalDeviceProperties2_self_partial(enc, val);
20681 }
20682
20683 /* struct VkDrmFormatModifierPropertiesEXT */
20684
20685 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT * val)20686 vn_sizeof_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT *val)
20687 {
20688 size_t size = 0;
20689 size += vn_sizeof_uint64_t(&val->drmFormatModifier);
20690 size += vn_sizeof_uint32_t(&val->drmFormatModifierPlaneCount);
20691 size += vn_sizeof_VkFlags(&val->drmFormatModifierTilingFeatures);
20692 return size;
20693 }
20694
20695 static inline void
vn_decode_VkDrmFormatModifierPropertiesEXT(struct vn_cs_decoder * dec,VkDrmFormatModifierPropertiesEXT * val)20696 vn_decode_VkDrmFormatModifierPropertiesEXT(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesEXT *val)
20697 {
20698 vn_decode_uint64_t(dec, &val->drmFormatModifier);
20699 vn_decode_uint32_t(dec, &val->drmFormatModifierPlaneCount);
20700 vn_decode_VkFlags(dec, &val->drmFormatModifierTilingFeatures);
20701 }
20702
20703 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesEXT_partial(const VkDrmFormatModifierPropertiesEXT * val)20704 vn_sizeof_VkDrmFormatModifierPropertiesEXT_partial(const VkDrmFormatModifierPropertiesEXT *val)
20705 {
20706 size_t size = 0;
20707 /* skip val->drmFormatModifier */
20708 /* skip val->drmFormatModifierPlaneCount */
20709 /* skip val->drmFormatModifierTilingFeatures */
20710 return size;
20711 }
20712
20713 static inline void
vn_encode_VkDrmFormatModifierPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkDrmFormatModifierPropertiesEXT * val)20714 vn_encode_VkDrmFormatModifierPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesEXT *val)
20715 {
20716 /* skip val->drmFormatModifier */
20717 /* skip val->drmFormatModifierPlaneCount */
20718 /* skip val->drmFormatModifierTilingFeatures */
20719 }
20720
20721 /* struct VkDrmFormatModifierPropertiesListEXT chain */
20722
20723 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext(const void * val)20724 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext(const void *val)
20725 {
20726 /* no known/supported struct */
20727 return vn_sizeof_simple_pointer(NULL);
20728 }
20729
20730 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self(const VkDrmFormatModifierPropertiesListEXT * val)20731 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self(const VkDrmFormatModifierPropertiesListEXT *val)
20732 {
20733 size_t size = 0;
20734 /* skip val->{sType,pNext} */
20735 size += vn_sizeof_uint32_t(&val->drmFormatModifierCount);
20736 if (val->pDrmFormatModifierProperties) {
20737 size += vn_sizeof_array_size(val->drmFormatModifierCount);
20738 for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
20739 size += vn_sizeof_VkDrmFormatModifierPropertiesEXT(&val->pDrmFormatModifierProperties[i]);
20740 } else {
20741 size += vn_sizeof_array_size(0);
20742 }
20743 return size;
20744 }
20745
20746 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT * val)20747 vn_sizeof_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT *val)
20748 {
20749 size_t size = 0;
20750
20751 size += vn_sizeof_VkStructureType(&val->sType);
20752 size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext(val->pNext);
20753 size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self(val);
20754
20755 return size;
20756 }
20757
20758 static inline void
vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext(struct vn_cs_decoder * dec,const void * val)20759 vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext(struct vn_cs_decoder *dec, const void *val)
20760 {
20761 /* no known/supported struct */
20762 if (vn_decode_simple_pointer(dec))
20763 assert(false);
20764 }
20765
20766 static inline void
vn_decode_VkDrmFormatModifierPropertiesListEXT_self(struct vn_cs_decoder * dec,VkDrmFormatModifierPropertiesListEXT * val)20767 vn_decode_VkDrmFormatModifierPropertiesListEXT_self(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesListEXT *val)
20768 {
20769 /* skip val->{sType,pNext} */
20770 vn_decode_uint32_t(dec, &val->drmFormatModifierCount);
20771 if (vn_peek_array_size(dec)) {
20772 const uint32_t iter_count = vn_decode_array_size(dec, val->drmFormatModifierCount);
20773 for (uint32_t i = 0; i < iter_count; i++)
20774 vn_decode_VkDrmFormatModifierPropertiesEXT(dec, &val->pDrmFormatModifierProperties[i]);
20775 } else {
20776 vn_decode_array_size_unchecked(dec);
20777 val->pDrmFormatModifierProperties = NULL;
20778 }
20779 }
20780
20781 static inline void
vn_decode_VkDrmFormatModifierPropertiesListEXT(struct vn_cs_decoder * dec,VkDrmFormatModifierPropertiesListEXT * val)20782 vn_decode_VkDrmFormatModifierPropertiesListEXT(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesListEXT *val)
20783 {
20784 VkStructureType stype;
20785 vn_decode_VkStructureType(dec, &stype);
20786 assert(stype == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT);
20787
20788 assert(val->sType == stype);
20789 vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext(dec, val->pNext);
20790 vn_decode_VkDrmFormatModifierPropertiesListEXT_self(dec, val);
20791 }
20792
20793 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext_partial(const void * val)20794 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext_partial(const void *val)
20795 {
20796 /* no known/supported struct */
20797 return vn_sizeof_simple_pointer(NULL);
20798 }
20799
20800 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial(const VkDrmFormatModifierPropertiesListEXT * val)20801 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial(const VkDrmFormatModifierPropertiesListEXT *val)
20802 {
20803 size_t size = 0;
20804 /* skip val->{sType,pNext} */
20805 size += vn_sizeof_uint32_t(&val->drmFormatModifierCount);
20806 if (val->pDrmFormatModifierProperties) {
20807 size += vn_sizeof_array_size(val->drmFormatModifierCount);
20808 for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
20809 size += vn_sizeof_VkDrmFormatModifierPropertiesEXT_partial(&val->pDrmFormatModifierProperties[i]);
20810 } else {
20811 size += vn_sizeof_array_size(0);
20812 }
20813 return size;
20814 }
20815
20816 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_partial(const VkDrmFormatModifierPropertiesListEXT * val)20817 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_partial(const VkDrmFormatModifierPropertiesListEXT *val)
20818 {
20819 size_t size = 0;
20820
20821 size += vn_sizeof_VkStructureType(&val->sType);
20822 size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext_partial(val->pNext);
20823 size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial(val);
20824
20825 return size;
20826 }
20827
20828 static inline void
vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)20829 vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
20830 {
20831 /* no known/supported struct */
20832 vn_encode_simple_pointer(enc, NULL);
20833 }
20834
20835 static inline void
vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(struct vn_cs_encoder * enc,const VkDrmFormatModifierPropertiesListEXT * val)20836 vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesListEXT *val)
20837 {
20838 /* skip val->{sType,pNext} */
20839 vn_encode_uint32_t(enc, &val->drmFormatModifierCount);
20840 if (val->pDrmFormatModifierProperties) {
20841 vn_encode_array_size(enc, val->drmFormatModifierCount);
20842 for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
20843 vn_encode_VkDrmFormatModifierPropertiesEXT_partial(enc, &val->pDrmFormatModifierProperties[i]);
20844 } else {
20845 vn_encode_array_size(enc, 0);
20846 }
20847 }
20848
20849 static inline void
vn_encode_VkDrmFormatModifierPropertiesListEXT_partial(struct vn_cs_encoder * enc,const VkDrmFormatModifierPropertiesListEXT * val)20850 vn_encode_VkDrmFormatModifierPropertiesListEXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesListEXT *val)
20851 {
20852 assert(val->sType == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT);
20853 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT });
20854 vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext_partial(enc, val->pNext);
20855 vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(enc, val);
20856 }
20857
20858 /* struct VkFormatProperties3 chain */
20859
20860 static inline size_t
vn_sizeof_VkFormatProperties3_pnext(const void * val)20861 vn_sizeof_VkFormatProperties3_pnext(const void *val)
20862 {
20863 /* no known/supported struct */
20864 return vn_sizeof_simple_pointer(NULL);
20865 }
20866
20867 static inline size_t
vn_sizeof_VkFormatProperties3_self(const VkFormatProperties3 * val)20868 vn_sizeof_VkFormatProperties3_self(const VkFormatProperties3 *val)
20869 {
20870 size_t size = 0;
20871 /* skip val->{sType,pNext} */
20872 size += vn_sizeof_VkFlags64(&val->linearTilingFeatures);
20873 size += vn_sizeof_VkFlags64(&val->optimalTilingFeatures);
20874 size += vn_sizeof_VkFlags64(&val->bufferFeatures);
20875 return size;
20876 }
20877
20878 static inline size_t
vn_sizeof_VkFormatProperties3(const VkFormatProperties3 * val)20879 vn_sizeof_VkFormatProperties3(const VkFormatProperties3 *val)
20880 {
20881 size_t size = 0;
20882
20883 size += vn_sizeof_VkStructureType(&val->sType);
20884 size += vn_sizeof_VkFormatProperties3_pnext(val->pNext);
20885 size += vn_sizeof_VkFormatProperties3_self(val);
20886
20887 return size;
20888 }
20889
20890 static inline void
vn_decode_VkFormatProperties3_pnext(struct vn_cs_decoder * dec,const void * val)20891 vn_decode_VkFormatProperties3_pnext(struct vn_cs_decoder *dec, const void *val)
20892 {
20893 /* no known/supported struct */
20894 if (vn_decode_simple_pointer(dec))
20895 assert(false);
20896 }
20897
20898 static inline void
vn_decode_VkFormatProperties3_self(struct vn_cs_decoder * dec,VkFormatProperties3 * val)20899 vn_decode_VkFormatProperties3_self(struct vn_cs_decoder *dec, VkFormatProperties3 *val)
20900 {
20901 /* skip val->{sType,pNext} */
20902 vn_decode_VkFlags64(dec, &val->linearTilingFeatures);
20903 vn_decode_VkFlags64(dec, &val->optimalTilingFeatures);
20904 vn_decode_VkFlags64(dec, &val->bufferFeatures);
20905 }
20906
20907 static inline void
vn_decode_VkFormatProperties3(struct vn_cs_decoder * dec,VkFormatProperties3 * val)20908 vn_decode_VkFormatProperties3(struct vn_cs_decoder *dec, VkFormatProperties3 *val)
20909 {
20910 VkStructureType stype;
20911 vn_decode_VkStructureType(dec, &stype);
20912 assert(stype == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3);
20913
20914 assert(val->sType == stype);
20915 vn_decode_VkFormatProperties3_pnext(dec, val->pNext);
20916 vn_decode_VkFormatProperties3_self(dec, val);
20917 }
20918
20919 static inline size_t
vn_sizeof_VkFormatProperties3_pnext_partial(const void * val)20920 vn_sizeof_VkFormatProperties3_pnext_partial(const void *val)
20921 {
20922 /* no known/supported struct */
20923 return vn_sizeof_simple_pointer(NULL);
20924 }
20925
20926 static inline size_t
vn_sizeof_VkFormatProperties3_self_partial(const VkFormatProperties3 * val)20927 vn_sizeof_VkFormatProperties3_self_partial(const VkFormatProperties3 *val)
20928 {
20929 size_t size = 0;
20930 /* skip val->{sType,pNext} */
20931 /* skip val->linearTilingFeatures */
20932 /* skip val->optimalTilingFeatures */
20933 /* skip val->bufferFeatures */
20934 return size;
20935 }
20936
20937 static inline size_t
vn_sizeof_VkFormatProperties3_partial(const VkFormatProperties3 * val)20938 vn_sizeof_VkFormatProperties3_partial(const VkFormatProperties3 *val)
20939 {
20940 size_t size = 0;
20941
20942 size += vn_sizeof_VkStructureType(&val->sType);
20943 size += vn_sizeof_VkFormatProperties3_pnext_partial(val->pNext);
20944 size += vn_sizeof_VkFormatProperties3_self_partial(val);
20945
20946 return size;
20947 }
20948
20949 static inline void
vn_encode_VkFormatProperties3_pnext_partial(struct vn_cs_encoder * enc,const void * val)20950 vn_encode_VkFormatProperties3_pnext_partial(struct vn_cs_encoder *enc, const void *val)
20951 {
20952 /* no known/supported struct */
20953 vn_encode_simple_pointer(enc, NULL);
20954 }
20955
20956 static inline void
vn_encode_VkFormatProperties3_self_partial(struct vn_cs_encoder * enc,const VkFormatProperties3 * val)20957 vn_encode_VkFormatProperties3_self_partial(struct vn_cs_encoder *enc, const VkFormatProperties3 *val)
20958 {
20959 /* skip val->{sType,pNext} */
20960 /* skip val->linearTilingFeatures */
20961 /* skip val->optimalTilingFeatures */
20962 /* skip val->bufferFeatures */
20963 }
20964
20965 static inline void
vn_encode_VkFormatProperties3_partial(struct vn_cs_encoder * enc,const VkFormatProperties3 * val)20966 vn_encode_VkFormatProperties3_partial(struct vn_cs_encoder *enc, const VkFormatProperties3 *val)
20967 {
20968 assert(val->sType == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3);
20969 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 });
20970 vn_encode_VkFormatProperties3_pnext_partial(enc, val->pNext);
20971 vn_encode_VkFormatProperties3_self_partial(enc, val);
20972 }
20973
20974 /* struct VkDrmFormatModifierProperties2EXT */
20975
20976 static inline size_t
vn_sizeof_VkDrmFormatModifierProperties2EXT(const VkDrmFormatModifierProperties2EXT * val)20977 vn_sizeof_VkDrmFormatModifierProperties2EXT(const VkDrmFormatModifierProperties2EXT *val)
20978 {
20979 size_t size = 0;
20980 size += vn_sizeof_uint64_t(&val->drmFormatModifier);
20981 size += vn_sizeof_uint32_t(&val->drmFormatModifierPlaneCount);
20982 size += vn_sizeof_VkFlags64(&val->drmFormatModifierTilingFeatures);
20983 return size;
20984 }
20985
20986 static inline void
vn_decode_VkDrmFormatModifierProperties2EXT(struct vn_cs_decoder * dec,VkDrmFormatModifierProperties2EXT * val)20987 vn_decode_VkDrmFormatModifierProperties2EXT(struct vn_cs_decoder *dec, VkDrmFormatModifierProperties2EXT *val)
20988 {
20989 vn_decode_uint64_t(dec, &val->drmFormatModifier);
20990 vn_decode_uint32_t(dec, &val->drmFormatModifierPlaneCount);
20991 vn_decode_VkFlags64(dec, &val->drmFormatModifierTilingFeatures);
20992 }
20993
20994 static inline size_t
vn_sizeof_VkDrmFormatModifierProperties2EXT_partial(const VkDrmFormatModifierProperties2EXT * val)20995 vn_sizeof_VkDrmFormatModifierProperties2EXT_partial(const VkDrmFormatModifierProperties2EXT *val)
20996 {
20997 size_t size = 0;
20998 /* skip val->drmFormatModifier */
20999 /* skip val->drmFormatModifierPlaneCount */
21000 /* skip val->drmFormatModifierTilingFeatures */
21001 return size;
21002 }
21003
21004 static inline void
vn_encode_VkDrmFormatModifierProperties2EXT_partial(struct vn_cs_encoder * enc,const VkDrmFormatModifierProperties2EXT * val)21005 vn_encode_VkDrmFormatModifierProperties2EXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierProperties2EXT *val)
21006 {
21007 /* skip val->drmFormatModifier */
21008 /* skip val->drmFormatModifierPlaneCount */
21009 /* skip val->drmFormatModifierTilingFeatures */
21010 }
21011
21012 /* struct VkDrmFormatModifierPropertiesList2EXT chain */
21013
21014 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_pnext(const void * val)21015 vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_pnext(const void *val)
21016 {
21017 /* no known/supported struct */
21018 return vn_sizeof_simple_pointer(NULL);
21019 }
21020
21021 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self(const VkDrmFormatModifierPropertiesList2EXT * val)21022 vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self(const VkDrmFormatModifierPropertiesList2EXT *val)
21023 {
21024 size_t size = 0;
21025 /* skip val->{sType,pNext} */
21026 size += vn_sizeof_uint32_t(&val->drmFormatModifierCount);
21027 if (val->pDrmFormatModifierProperties) {
21028 size += vn_sizeof_array_size(val->drmFormatModifierCount);
21029 for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
21030 size += vn_sizeof_VkDrmFormatModifierProperties2EXT(&val->pDrmFormatModifierProperties[i]);
21031 } else {
21032 size += vn_sizeof_array_size(0);
21033 }
21034 return size;
21035 }
21036
21037 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesList2EXT(const VkDrmFormatModifierPropertiesList2EXT * val)21038 vn_sizeof_VkDrmFormatModifierPropertiesList2EXT(const VkDrmFormatModifierPropertiesList2EXT *val)
21039 {
21040 size_t size = 0;
21041
21042 size += vn_sizeof_VkStructureType(&val->sType);
21043 size += vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_pnext(val->pNext);
21044 size += vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self(val);
21045
21046 return size;
21047 }
21048
21049 static inline void
vn_decode_VkDrmFormatModifierPropertiesList2EXT_pnext(struct vn_cs_decoder * dec,const void * val)21050 vn_decode_VkDrmFormatModifierPropertiesList2EXT_pnext(struct vn_cs_decoder *dec, const void *val)
21051 {
21052 /* no known/supported struct */
21053 if (vn_decode_simple_pointer(dec))
21054 assert(false);
21055 }
21056
21057 static inline void
vn_decode_VkDrmFormatModifierPropertiesList2EXT_self(struct vn_cs_decoder * dec,VkDrmFormatModifierPropertiesList2EXT * val)21058 vn_decode_VkDrmFormatModifierPropertiesList2EXT_self(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesList2EXT *val)
21059 {
21060 /* skip val->{sType,pNext} */
21061 vn_decode_uint32_t(dec, &val->drmFormatModifierCount);
21062 if (vn_peek_array_size(dec)) {
21063 const uint32_t iter_count = vn_decode_array_size(dec, val->drmFormatModifierCount);
21064 for (uint32_t i = 0; i < iter_count; i++)
21065 vn_decode_VkDrmFormatModifierProperties2EXT(dec, &val->pDrmFormatModifierProperties[i]);
21066 } else {
21067 vn_decode_array_size_unchecked(dec);
21068 val->pDrmFormatModifierProperties = NULL;
21069 }
21070 }
21071
21072 static inline void
vn_decode_VkDrmFormatModifierPropertiesList2EXT(struct vn_cs_decoder * dec,VkDrmFormatModifierPropertiesList2EXT * val)21073 vn_decode_VkDrmFormatModifierPropertiesList2EXT(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesList2EXT *val)
21074 {
21075 VkStructureType stype;
21076 vn_decode_VkStructureType(dec, &stype);
21077 assert(stype == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT);
21078
21079 assert(val->sType == stype);
21080 vn_decode_VkDrmFormatModifierPropertiesList2EXT_pnext(dec, val->pNext);
21081 vn_decode_VkDrmFormatModifierPropertiesList2EXT_self(dec, val);
21082 }
21083
21084 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_pnext_partial(const void * val)21085 vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_pnext_partial(const void *val)
21086 {
21087 /* no known/supported struct */
21088 return vn_sizeof_simple_pointer(NULL);
21089 }
21090
21091 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self_partial(const VkDrmFormatModifierPropertiesList2EXT * val)21092 vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self_partial(const VkDrmFormatModifierPropertiesList2EXT *val)
21093 {
21094 size_t size = 0;
21095 /* skip val->{sType,pNext} */
21096 size += vn_sizeof_uint32_t(&val->drmFormatModifierCount);
21097 if (val->pDrmFormatModifierProperties) {
21098 size += vn_sizeof_array_size(val->drmFormatModifierCount);
21099 for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
21100 size += vn_sizeof_VkDrmFormatModifierProperties2EXT_partial(&val->pDrmFormatModifierProperties[i]);
21101 } else {
21102 size += vn_sizeof_array_size(0);
21103 }
21104 return size;
21105 }
21106
21107 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_partial(const VkDrmFormatModifierPropertiesList2EXT * val)21108 vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_partial(const VkDrmFormatModifierPropertiesList2EXT *val)
21109 {
21110 size_t size = 0;
21111
21112 size += vn_sizeof_VkStructureType(&val->sType);
21113 size += vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_pnext_partial(val->pNext);
21114 size += vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self_partial(val);
21115
21116 return size;
21117 }
21118
21119 static inline void
vn_encode_VkDrmFormatModifierPropertiesList2EXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)21120 vn_encode_VkDrmFormatModifierPropertiesList2EXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
21121 {
21122 /* no known/supported struct */
21123 vn_encode_simple_pointer(enc, NULL);
21124 }
21125
21126 static inline void
vn_encode_VkDrmFormatModifierPropertiesList2EXT_self_partial(struct vn_cs_encoder * enc,const VkDrmFormatModifierPropertiesList2EXT * val)21127 vn_encode_VkDrmFormatModifierPropertiesList2EXT_self_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesList2EXT *val)
21128 {
21129 /* skip val->{sType,pNext} */
21130 vn_encode_uint32_t(enc, &val->drmFormatModifierCount);
21131 if (val->pDrmFormatModifierProperties) {
21132 vn_encode_array_size(enc, val->drmFormatModifierCount);
21133 for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
21134 vn_encode_VkDrmFormatModifierProperties2EXT_partial(enc, &val->pDrmFormatModifierProperties[i]);
21135 } else {
21136 vn_encode_array_size(enc, 0);
21137 }
21138 }
21139
21140 static inline void
vn_encode_VkDrmFormatModifierPropertiesList2EXT_partial(struct vn_cs_encoder * enc,const VkDrmFormatModifierPropertiesList2EXT * val)21141 vn_encode_VkDrmFormatModifierPropertiesList2EXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesList2EXT *val)
21142 {
21143 assert(val->sType == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT);
21144 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT });
21145 vn_encode_VkDrmFormatModifierPropertiesList2EXT_pnext_partial(enc, val->pNext);
21146 vn_encode_VkDrmFormatModifierPropertiesList2EXT_self_partial(enc, val);
21147 }
21148
21149 /* struct VkFormatProperties2 chain */
21150
21151 static inline size_t
vn_sizeof_VkFormatProperties2_pnext(const void * val)21152 vn_sizeof_VkFormatProperties2_pnext(const void *val)
21153 {
21154 const VkBaseInStructure *pnext = val;
21155 size_t size = 0;
21156
21157 while (pnext) {
21158 switch ((int32_t)pnext->sType) {
21159 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
21160 if (!vn_cs_renderer_protocol_has_extension(159 /* VK_EXT_image_drm_format_modifier */))
21161 break;
21162 size += vn_sizeof_simple_pointer(pnext);
21163 size += vn_sizeof_VkStructureType(&pnext->sType);
21164 size += vn_sizeof_VkFormatProperties2_pnext(pnext->pNext);
21165 size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self((const VkDrmFormatModifierPropertiesListEXT *)pnext);
21166 return size;
21167 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
21168 if (!vn_cs_renderer_protocol_has_extension(361 /* VK_KHR_format_feature_flags2 */))
21169 break;
21170 size += vn_sizeof_simple_pointer(pnext);
21171 size += vn_sizeof_VkStructureType(&pnext->sType);
21172 size += vn_sizeof_VkFormatProperties2_pnext(pnext->pNext);
21173 size += vn_sizeof_VkFormatProperties3_self((const VkFormatProperties3 *)pnext);
21174 return size;
21175 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
21176 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 */)))
21177 break;
21178 size += vn_sizeof_simple_pointer(pnext);
21179 size += vn_sizeof_VkStructureType(&pnext->sType);
21180 size += vn_sizeof_VkFormatProperties2_pnext(pnext->pNext);
21181 size += vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self((const VkDrmFormatModifierPropertiesList2EXT *)pnext);
21182 return size;
21183 default:
21184 /* ignore unknown/unsupported struct */
21185 break;
21186 }
21187 pnext = pnext->pNext;
21188 }
21189
21190 return vn_sizeof_simple_pointer(NULL);
21191 }
21192
21193 static inline size_t
vn_sizeof_VkFormatProperties2_self(const VkFormatProperties2 * val)21194 vn_sizeof_VkFormatProperties2_self(const VkFormatProperties2 *val)
21195 {
21196 size_t size = 0;
21197 /* skip val->{sType,pNext} */
21198 size += vn_sizeof_VkFormatProperties(&val->formatProperties);
21199 return size;
21200 }
21201
21202 static inline size_t
vn_sizeof_VkFormatProperties2(const VkFormatProperties2 * val)21203 vn_sizeof_VkFormatProperties2(const VkFormatProperties2 *val)
21204 {
21205 size_t size = 0;
21206
21207 size += vn_sizeof_VkStructureType(&val->sType);
21208 size += vn_sizeof_VkFormatProperties2_pnext(val->pNext);
21209 size += vn_sizeof_VkFormatProperties2_self(val);
21210
21211 return size;
21212 }
21213
21214 static inline void
vn_decode_VkFormatProperties2_pnext(struct vn_cs_decoder * dec,const void * val)21215 vn_decode_VkFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
21216 {
21217 VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
21218 VkStructureType stype;
21219
21220 if (!vn_decode_simple_pointer(dec))
21221 return;
21222
21223 vn_decode_VkStructureType(dec, &stype);
21224 while (true) {
21225 assert(pnext);
21226 if (pnext->sType == stype)
21227 break;
21228
21229 pnext = pnext->pNext;
21230 }
21231
21232 switch ((int32_t)pnext->sType) {
21233 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
21234 vn_decode_VkFormatProperties2_pnext(dec, pnext->pNext);
21235 vn_decode_VkDrmFormatModifierPropertiesListEXT_self(dec, (VkDrmFormatModifierPropertiesListEXT *)pnext);
21236 break;
21237 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
21238 vn_decode_VkFormatProperties2_pnext(dec, pnext->pNext);
21239 vn_decode_VkFormatProperties3_self(dec, (VkFormatProperties3 *)pnext);
21240 break;
21241 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
21242 vn_decode_VkFormatProperties2_pnext(dec, pnext->pNext);
21243 vn_decode_VkDrmFormatModifierPropertiesList2EXT_self(dec, (VkDrmFormatModifierPropertiesList2EXT *)pnext);
21244 break;
21245 default:
21246 assert(false);
21247 break;
21248 }
21249 }
21250
21251 static inline void
vn_decode_VkFormatProperties2_self(struct vn_cs_decoder * dec,VkFormatProperties2 * val)21252 vn_decode_VkFormatProperties2_self(struct vn_cs_decoder *dec, VkFormatProperties2 *val)
21253 {
21254 /* skip val->{sType,pNext} */
21255 vn_decode_VkFormatProperties(dec, &val->formatProperties);
21256 }
21257
21258 static inline void
vn_decode_VkFormatProperties2(struct vn_cs_decoder * dec,VkFormatProperties2 * val)21259 vn_decode_VkFormatProperties2(struct vn_cs_decoder *dec, VkFormatProperties2 *val)
21260 {
21261 VkStructureType stype;
21262 vn_decode_VkStructureType(dec, &stype);
21263 assert(stype == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
21264
21265 assert(val->sType == stype);
21266 vn_decode_VkFormatProperties2_pnext(dec, val->pNext);
21267 vn_decode_VkFormatProperties2_self(dec, val);
21268 }
21269
21270 static inline size_t
vn_sizeof_VkFormatProperties2_pnext_partial(const void * val)21271 vn_sizeof_VkFormatProperties2_pnext_partial(const void *val)
21272 {
21273 const VkBaseInStructure *pnext = val;
21274 size_t size = 0;
21275
21276 while (pnext) {
21277 switch ((int32_t)pnext->sType) {
21278 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
21279 if (!vn_cs_renderer_protocol_has_extension(159 /* VK_EXT_image_drm_format_modifier */))
21280 break;
21281 size += vn_sizeof_simple_pointer(pnext);
21282 size += vn_sizeof_VkStructureType(&pnext->sType);
21283 size += vn_sizeof_VkFormatProperties2_pnext_partial(pnext->pNext);
21284 size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial((const VkDrmFormatModifierPropertiesListEXT *)pnext);
21285 return size;
21286 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
21287 if (!vn_cs_renderer_protocol_has_extension(361 /* VK_KHR_format_feature_flags2 */))
21288 break;
21289 size += vn_sizeof_simple_pointer(pnext);
21290 size += vn_sizeof_VkStructureType(&pnext->sType);
21291 size += vn_sizeof_VkFormatProperties2_pnext_partial(pnext->pNext);
21292 size += vn_sizeof_VkFormatProperties3_self_partial((const VkFormatProperties3 *)pnext);
21293 return size;
21294 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
21295 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 */)))
21296 break;
21297 size += vn_sizeof_simple_pointer(pnext);
21298 size += vn_sizeof_VkStructureType(&pnext->sType);
21299 size += vn_sizeof_VkFormatProperties2_pnext_partial(pnext->pNext);
21300 size += vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self_partial((const VkDrmFormatModifierPropertiesList2EXT *)pnext);
21301 return size;
21302 default:
21303 /* ignore unknown/unsupported struct */
21304 break;
21305 }
21306 pnext = pnext->pNext;
21307 }
21308
21309 return vn_sizeof_simple_pointer(NULL);
21310 }
21311
21312 static inline size_t
vn_sizeof_VkFormatProperties2_self_partial(const VkFormatProperties2 * val)21313 vn_sizeof_VkFormatProperties2_self_partial(const VkFormatProperties2 *val)
21314 {
21315 size_t size = 0;
21316 /* skip val->{sType,pNext} */
21317 size += vn_sizeof_VkFormatProperties_partial(&val->formatProperties);
21318 return size;
21319 }
21320
21321 static inline size_t
vn_sizeof_VkFormatProperties2_partial(const VkFormatProperties2 * val)21322 vn_sizeof_VkFormatProperties2_partial(const VkFormatProperties2 *val)
21323 {
21324 size_t size = 0;
21325
21326 size += vn_sizeof_VkStructureType(&val->sType);
21327 size += vn_sizeof_VkFormatProperties2_pnext_partial(val->pNext);
21328 size += vn_sizeof_VkFormatProperties2_self_partial(val);
21329
21330 return size;
21331 }
21332
21333 static inline void
vn_encode_VkFormatProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)21334 vn_encode_VkFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
21335 {
21336 const VkBaseInStructure *pnext = val;
21337
21338 while (pnext) {
21339 switch ((int32_t)pnext->sType) {
21340 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
21341 if (!vn_cs_renderer_protocol_has_extension(159 /* VK_EXT_image_drm_format_modifier */))
21342 break;
21343 vn_encode_simple_pointer(enc, pnext);
21344 vn_encode_VkStructureType(enc, &pnext->sType);
21345 vn_encode_VkFormatProperties2_pnext_partial(enc, pnext->pNext);
21346 vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(enc, (const VkDrmFormatModifierPropertiesListEXT *)pnext);
21347 return;
21348 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
21349 if (!vn_cs_renderer_protocol_has_extension(361 /* VK_KHR_format_feature_flags2 */))
21350 break;
21351 vn_encode_simple_pointer(enc, pnext);
21352 vn_encode_VkStructureType(enc, &pnext->sType);
21353 vn_encode_VkFormatProperties2_pnext_partial(enc, pnext->pNext);
21354 vn_encode_VkFormatProperties3_self_partial(enc, (const VkFormatProperties3 *)pnext);
21355 return;
21356 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
21357 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 */)))
21358 break;
21359 vn_encode_simple_pointer(enc, pnext);
21360 vn_encode_VkStructureType(enc, &pnext->sType);
21361 vn_encode_VkFormatProperties2_pnext_partial(enc, pnext->pNext);
21362 vn_encode_VkDrmFormatModifierPropertiesList2EXT_self_partial(enc, (const VkDrmFormatModifierPropertiesList2EXT *)pnext);
21363 return;
21364 default:
21365 /* ignore unknown/unsupported struct */
21366 break;
21367 }
21368 pnext = pnext->pNext;
21369 }
21370
21371 vn_encode_simple_pointer(enc, NULL);
21372 }
21373
21374 static inline void
vn_encode_VkFormatProperties2_self_partial(struct vn_cs_encoder * enc,const VkFormatProperties2 * val)21375 vn_encode_VkFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkFormatProperties2 *val)
21376 {
21377 /* skip val->{sType,pNext} */
21378 vn_encode_VkFormatProperties_partial(enc, &val->formatProperties);
21379 }
21380
21381 static inline void
vn_encode_VkFormatProperties2_partial(struct vn_cs_encoder * enc,const VkFormatProperties2 * val)21382 vn_encode_VkFormatProperties2_partial(struct vn_cs_encoder *enc, const VkFormatProperties2 *val)
21383 {
21384 assert(val->sType == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
21385 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 });
21386 vn_encode_VkFormatProperties2_pnext_partial(enc, val->pNext);
21387 vn_encode_VkFormatProperties2_self_partial(enc, val);
21388 }
21389
21390 /* struct VkPhysicalDeviceExternalImageFormatInfo chain */
21391
21392 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_pnext(const void * val)21393 vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_pnext(const void *val)
21394 {
21395 /* no known/supported struct */
21396 return vn_sizeof_simple_pointer(NULL);
21397 }
21398
21399 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self(const VkPhysicalDeviceExternalImageFormatInfo * val)21400 vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self(const VkPhysicalDeviceExternalImageFormatInfo *val)
21401 {
21402 size_t size = 0;
21403 /* skip val->{sType,pNext} */
21404 size += vn_sizeof_VkExternalMemoryHandleTypeFlagBits(&val->handleType);
21405 return size;
21406 }
21407
21408 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo * val)21409 vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo *val)
21410 {
21411 size_t size = 0;
21412
21413 size += vn_sizeof_VkStructureType(&val->sType);
21414 size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_pnext(val->pNext);
21415 size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self(val);
21416
21417 return size;
21418 }
21419
21420 static inline void
vn_encode_VkPhysicalDeviceExternalImageFormatInfo_pnext(struct vn_cs_encoder * enc,const void * val)21421 vn_encode_VkPhysicalDeviceExternalImageFormatInfo_pnext(struct vn_cs_encoder *enc, const void *val)
21422 {
21423 /* no known/supported struct */
21424 vn_encode_simple_pointer(enc, NULL);
21425 }
21426
21427 static inline void
vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalImageFormatInfo * val)21428 vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalImageFormatInfo *val)
21429 {
21430 /* skip val->{sType,pNext} */
21431 vn_encode_VkExternalMemoryHandleTypeFlagBits(enc, &val->handleType);
21432 }
21433
21434 static inline void
vn_encode_VkPhysicalDeviceExternalImageFormatInfo(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalImageFormatInfo * val)21435 vn_encode_VkPhysicalDeviceExternalImageFormatInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalImageFormatInfo *val)
21436 {
21437 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO);
21438 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO });
21439 vn_encode_VkPhysicalDeviceExternalImageFormatInfo_pnext(enc, val->pNext);
21440 vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(enc, val);
21441 }
21442
21443 /* struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT chain */
21444
21445 static inline size_t
vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(const void * val)21446 vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(const void *val)
21447 {
21448 /* no known/supported struct */
21449 return vn_sizeof_simple_pointer(NULL);
21450 }
21451
21452 static inline size_t
vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)21453 vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
21454 {
21455 size_t size = 0;
21456 /* skip val->{sType,pNext} */
21457 size += vn_sizeof_uint64_t(&val->drmFormatModifier);
21458 size += vn_sizeof_VkSharingMode(&val->sharingMode);
21459 size += vn_sizeof_uint32_t(&val->queueFamilyIndexCount);
21460 if (val->sharingMode == VK_SHARING_MODE_CONCURRENT) {
21461 size += vn_sizeof_array_size(val->queueFamilyIndexCount);
21462 size += vn_sizeof_uint32_t_array(val->pQueueFamilyIndices, val->queueFamilyIndexCount);
21463 } else {
21464 size += vn_sizeof_array_size(0);
21465 }
21466 return size;
21467 }
21468
21469 static inline size_t
vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)21470 vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
21471 {
21472 size_t size = 0;
21473
21474 size += vn_sizeof_VkStructureType(&val->sType);
21475 size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(val->pNext);
21476 size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(val);
21477
21478 return size;
21479 }
21480
21481 static inline void
vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)21482 vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
21483 {
21484 /* no known/supported struct */
21485 vn_encode_simple_pointer(enc, NULL);
21486 }
21487
21488 static inline void
vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)21489 vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
21490 {
21491 /* skip val->{sType,pNext} */
21492 vn_encode_uint64_t(enc, &val->drmFormatModifier);
21493 vn_encode_VkSharingMode(enc, &val->sharingMode);
21494 vn_encode_uint32_t(enc, &val->queueFamilyIndexCount);
21495 if (val->sharingMode == VK_SHARING_MODE_CONCURRENT) {
21496 vn_encode_array_size(enc, val->queueFamilyIndexCount);
21497 vn_encode_uint32_t_array(enc, val->pQueueFamilyIndices, val->queueFamilyIndexCount);
21498 } else {
21499 vn_encode_array_size(enc, 0);
21500 }
21501 }
21502
21503 static inline void
vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)21504 vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
21505 {
21506 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT);
21507 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT });
21508 vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(enc, val->pNext);
21509 vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(enc, val);
21510 }
21511
21512 /* struct VkPhysicalDeviceImageFormatInfo2 chain */
21513
21514 static inline size_t
vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(const void * val)21515 vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(const void *val)
21516 {
21517 const VkBaseInStructure *pnext = val;
21518 size_t size = 0;
21519
21520 while (pnext) {
21521 switch ((int32_t)pnext->sType) {
21522 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
21523 size += vn_sizeof_simple_pointer(pnext);
21524 size += vn_sizeof_VkStructureType(&pnext->sType);
21525 size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
21526 size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self((const VkPhysicalDeviceExternalImageFormatInfo *)pnext);
21527 return size;
21528 case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
21529 size += vn_sizeof_simple_pointer(pnext);
21530 size += vn_sizeof_VkStructureType(&pnext->sType);
21531 size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
21532 size += vn_sizeof_VkImageFormatListCreateInfo_self((const VkImageFormatListCreateInfo *)pnext);
21533 return size;
21534 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
21535 if (!vn_cs_renderer_protocol_has_extension(159 /* VK_EXT_image_drm_format_modifier */))
21536 break;
21537 size += vn_sizeof_simple_pointer(pnext);
21538 size += vn_sizeof_VkStructureType(&pnext->sType);
21539 size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
21540 size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self((const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)pnext);
21541 return size;
21542 case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
21543 size += vn_sizeof_simple_pointer(pnext);
21544 size += vn_sizeof_VkStructureType(&pnext->sType);
21545 size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
21546 size += vn_sizeof_VkImageStencilUsageCreateInfo_self((const VkImageStencilUsageCreateInfo *)pnext);
21547 return size;
21548 default:
21549 /* ignore unknown/unsupported struct */
21550 break;
21551 }
21552 pnext = pnext->pNext;
21553 }
21554
21555 return vn_sizeof_simple_pointer(NULL);
21556 }
21557
21558 static inline size_t
vn_sizeof_VkPhysicalDeviceImageFormatInfo2_self(const VkPhysicalDeviceImageFormatInfo2 * val)21559 vn_sizeof_VkPhysicalDeviceImageFormatInfo2_self(const VkPhysicalDeviceImageFormatInfo2 *val)
21560 {
21561 size_t size = 0;
21562 /* skip val->{sType,pNext} */
21563 size += vn_sizeof_VkFormat(&val->format);
21564 size += vn_sizeof_VkImageType(&val->type);
21565 size += vn_sizeof_VkImageTiling(&val->tiling);
21566 size += vn_sizeof_VkFlags(&val->usage);
21567 size += vn_sizeof_VkFlags(&val->flags);
21568 return size;
21569 }
21570
21571 static inline size_t
vn_sizeof_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2 * val)21572 vn_sizeof_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2 *val)
21573 {
21574 size_t size = 0;
21575
21576 size += vn_sizeof_VkStructureType(&val->sType);
21577 size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(val->pNext);
21578 size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_self(val);
21579
21580 return size;
21581 }
21582
21583 static inline void
vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(struct vn_cs_encoder * enc,const void * val)21584 vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
21585 {
21586 const VkBaseInStructure *pnext = val;
21587
21588 while (pnext) {
21589 switch ((int32_t)pnext->sType) {
21590 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
21591 vn_encode_simple_pointer(enc, pnext);
21592 vn_encode_VkStructureType(enc, &pnext->sType);
21593 vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
21594 vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(enc, (const VkPhysicalDeviceExternalImageFormatInfo *)pnext);
21595 return;
21596 case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
21597 vn_encode_simple_pointer(enc, pnext);
21598 vn_encode_VkStructureType(enc, &pnext->sType);
21599 vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
21600 vn_encode_VkImageFormatListCreateInfo_self(enc, (const VkImageFormatListCreateInfo *)pnext);
21601 return;
21602 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
21603 if (!vn_cs_renderer_protocol_has_extension(159 /* VK_EXT_image_drm_format_modifier */))
21604 break;
21605 vn_encode_simple_pointer(enc, pnext);
21606 vn_encode_VkStructureType(enc, &pnext->sType);
21607 vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
21608 vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(enc, (const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)pnext);
21609 return;
21610 case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
21611 vn_encode_simple_pointer(enc, pnext);
21612 vn_encode_VkStructureType(enc, &pnext->sType);
21613 vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
21614 vn_encode_VkImageStencilUsageCreateInfo_self(enc, (const VkImageStencilUsageCreateInfo *)pnext);
21615 return;
21616 default:
21617 /* ignore unknown/unsupported struct */
21618 break;
21619 }
21620 pnext = pnext->pNext;
21621 }
21622
21623 vn_encode_simple_pointer(enc, NULL);
21624 }
21625
21626 static inline void
vn_encode_VkPhysicalDeviceImageFormatInfo2_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageFormatInfo2 * val)21627 vn_encode_VkPhysicalDeviceImageFormatInfo2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageFormatInfo2 *val)
21628 {
21629 /* skip val->{sType,pNext} */
21630 vn_encode_VkFormat(enc, &val->format);
21631 vn_encode_VkImageType(enc, &val->type);
21632 vn_encode_VkImageTiling(enc, &val->tiling);
21633 vn_encode_VkFlags(enc, &val->usage);
21634 vn_encode_VkFlags(enc, &val->flags);
21635 }
21636
21637 static inline void
vn_encode_VkPhysicalDeviceImageFormatInfo2(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageFormatInfo2 * val)21638 vn_encode_VkPhysicalDeviceImageFormatInfo2(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageFormatInfo2 *val)
21639 {
21640 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2);
21641 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 });
21642 vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, val->pNext);
21643 vn_encode_VkPhysicalDeviceImageFormatInfo2_self(enc, val);
21644 }
21645
21646 /* struct VkExternalMemoryProperties */
21647
21648 static inline size_t
vn_sizeof_VkExternalMemoryProperties(const VkExternalMemoryProperties * val)21649 vn_sizeof_VkExternalMemoryProperties(const VkExternalMemoryProperties *val)
21650 {
21651 size_t size = 0;
21652 size += vn_sizeof_VkFlags(&val->externalMemoryFeatures);
21653 size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes);
21654 size += vn_sizeof_VkFlags(&val->compatibleHandleTypes);
21655 return size;
21656 }
21657
21658 static inline void
vn_decode_VkExternalMemoryProperties(struct vn_cs_decoder * dec,VkExternalMemoryProperties * val)21659 vn_decode_VkExternalMemoryProperties(struct vn_cs_decoder *dec, VkExternalMemoryProperties *val)
21660 {
21661 vn_decode_VkFlags(dec, &val->externalMemoryFeatures);
21662 vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes);
21663 vn_decode_VkFlags(dec, &val->compatibleHandleTypes);
21664 }
21665
21666 static inline size_t
vn_sizeof_VkExternalMemoryProperties_partial(const VkExternalMemoryProperties * val)21667 vn_sizeof_VkExternalMemoryProperties_partial(const VkExternalMemoryProperties *val)
21668 {
21669 size_t size = 0;
21670 /* skip val->externalMemoryFeatures */
21671 /* skip val->exportFromImportedHandleTypes */
21672 /* skip val->compatibleHandleTypes */
21673 return size;
21674 }
21675
21676 static inline void
vn_encode_VkExternalMemoryProperties_partial(struct vn_cs_encoder * enc,const VkExternalMemoryProperties * val)21677 vn_encode_VkExternalMemoryProperties_partial(struct vn_cs_encoder *enc, const VkExternalMemoryProperties *val)
21678 {
21679 /* skip val->externalMemoryFeatures */
21680 /* skip val->exportFromImportedHandleTypes */
21681 /* skip val->compatibleHandleTypes */
21682 }
21683
21684 /* struct VkExternalImageFormatProperties chain */
21685
21686 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_pnext(const void * val)21687 vn_sizeof_VkExternalImageFormatProperties_pnext(const void *val)
21688 {
21689 /* no known/supported struct */
21690 return vn_sizeof_simple_pointer(NULL);
21691 }
21692
21693 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_self(const VkExternalImageFormatProperties * val)21694 vn_sizeof_VkExternalImageFormatProperties_self(const VkExternalImageFormatProperties *val)
21695 {
21696 size_t size = 0;
21697 /* skip val->{sType,pNext} */
21698 size += vn_sizeof_VkExternalMemoryProperties(&val->externalMemoryProperties);
21699 return size;
21700 }
21701
21702 static inline size_t
vn_sizeof_VkExternalImageFormatProperties(const VkExternalImageFormatProperties * val)21703 vn_sizeof_VkExternalImageFormatProperties(const VkExternalImageFormatProperties *val)
21704 {
21705 size_t size = 0;
21706
21707 size += vn_sizeof_VkStructureType(&val->sType);
21708 size += vn_sizeof_VkExternalImageFormatProperties_pnext(val->pNext);
21709 size += vn_sizeof_VkExternalImageFormatProperties_self(val);
21710
21711 return size;
21712 }
21713
21714 static inline void
vn_decode_VkExternalImageFormatProperties_pnext(struct vn_cs_decoder * dec,const void * val)21715 vn_decode_VkExternalImageFormatProperties_pnext(struct vn_cs_decoder *dec, const void *val)
21716 {
21717 /* no known/supported struct */
21718 if (vn_decode_simple_pointer(dec))
21719 assert(false);
21720 }
21721
21722 static inline void
vn_decode_VkExternalImageFormatProperties_self(struct vn_cs_decoder * dec,VkExternalImageFormatProperties * val)21723 vn_decode_VkExternalImageFormatProperties_self(struct vn_cs_decoder *dec, VkExternalImageFormatProperties *val)
21724 {
21725 /* skip val->{sType,pNext} */
21726 vn_decode_VkExternalMemoryProperties(dec, &val->externalMemoryProperties);
21727 }
21728
21729 static inline void
vn_decode_VkExternalImageFormatProperties(struct vn_cs_decoder * dec,VkExternalImageFormatProperties * val)21730 vn_decode_VkExternalImageFormatProperties(struct vn_cs_decoder *dec, VkExternalImageFormatProperties *val)
21731 {
21732 VkStructureType stype;
21733 vn_decode_VkStructureType(dec, &stype);
21734 assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
21735
21736 assert(val->sType == stype);
21737 vn_decode_VkExternalImageFormatProperties_pnext(dec, val->pNext);
21738 vn_decode_VkExternalImageFormatProperties_self(dec, val);
21739 }
21740
21741 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_pnext_partial(const void * val)21742 vn_sizeof_VkExternalImageFormatProperties_pnext_partial(const void *val)
21743 {
21744 /* no known/supported struct */
21745 return vn_sizeof_simple_pointer(NULL);
21746 }
21747
21748 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_self_partial(const VkExternalImageFormatProperties * val)21749 vn_sizeof_VkExternalImageFormatProperties_self_partial(const VkExternalImageFormatProperties *val)
21750 {
21751 size_t size = 0;
21752 /* skip val->{sType,pNext} */
21753 size += vn_sizeof_VkExternalMemoryProperties_partial(&val->externalMemoryProperties);
21754 return size;
21755 }
21756
21757 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_partial(const VkExternalImageFormatProperties * val)21758 vn_sizeof_VkExternalImageFormatProperties_partial(const VkExternalImageFormatProperties *val)
21759 {
21760 size_t size = 0;
21761
21762 size += vn_sizeof_VkStructureType(&val->sType);
21763 size += vn_sizeof_VkExternalImageFormatProperties_pnext_partial(val->pNext);
21764 size += vn_sizeof_VkExternalImageFormatProperties_self_partial(val);
21765
21766 return size;
21767 }
21768
21769 static inline void
vn_encode_VkExternalImageFormatProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)21770 vn_encode_VkExternalImageFormatProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
21771 {
21772 /* no known/supported struct */
21773 vn_encode_simple_pointer(enc, NULL);
21774 }
21775
21776 static inline void
vn_encode_VkExternalImageFormatProperties_self_partial(struct vn_cs_encoder * enc,const VkExternalImageFormatProperties * val)21777 vn_encode_VkExternalImageFormatProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalImageFormatProperties *val)
21778 {
21779 /* skip val->{sType,pNext} */
21780 vn_encode_VkExternalMemoryProperties_partial(enc, &val->externalMemoryProperties);
21781 }
21782
21783 static inline void
vn_encode_VkExternalImageFormatProperties_partial(struct vn_cs_encoder * enc,const VkExternalImageFormatProperties * val)21784 vn_encode_VkExternalImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkExternalImageFormatProperties *val)
21785 {
21786 assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
21787 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES });
21788 vn_encode_VkExternalImageFormatProperties_pnext_partial(enc, val->pNext);
21789 vn_encode_VkExternalImageFormatProperties_self_partial(enc, val);
21790 }
21791
21792 /* struct VkSamplerYcbcrConversionImageFormatProperties chain */
21793
21794 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext(const void * val)21795 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext(const void *val)
21796 {
21797 /* no known/supported struct */
21798 return vn_sizeof_simple_pointer(NULL);
21799 }
21800
21801 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self(const VkSamplerYcbcrConversionImageFormatProperties * val)21802 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self(const VkSamplerYcbcrConversionImageFormatProperties *val)
21803 {
21804 size_t size = 0;
21805 /* skip val->{sType,pNext} */
21806 size += vn_sizeof_uint32_t(&val->combinedImageSamplerDescriptorCount);
21807 return size;
21808 }
21809
21810 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties * val)21811 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties *val)
21812 {
21813 size_t size = 0;
21814
21815 size += vn_sizeof_VkStructureType(&val->sType);
21816 size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext(val->pNext);
21817 size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self(val);
21818
21819 return size;
21820 }
21821
21822 static inline void
vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext(struct vn_cs_decoder * dec,const void * val)21823 vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext(struct vn_cs_decoder *dec, const void *val)
21824 {
21825 /* no known/supported struct */
21826 if (vn_decode_simple_pointer(dec))
21827 assert(false);
21828 }
21829
21830 static inline void
vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(struct vn_cs_decoder * dec,VkSamplerYcbcrConversionImageFormatProperties * val)21831 vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(struct vn_cs_decoder *dec, VkSamplerYcbcrConversionImageFormatProperties *val)
21832 {
21833 /* skip val->{sType,pNext} */
21834 vn_decode_uint32_t(dec, &val->combinedImageSamplerDescriptorCount);
21835 }
21836
21837 static inline void
vn_decode_VkSamplerYcbcrConversionImageFormatProperties(struct vn_cs_decoder * dec,VkSamplerYcbcrConversionImageFormatProperties * val)21838 vn_decode_VkSamplerYcbcrConversionImageFormatProperties(struct vn_cs_decoder *dec, VkSamplerYcbcrConversionImageFormatProperties *val)
21839 {
21840 VkStructureType stype;
21841 vn_decode_VkStructureType(dec, &stype);
21842 assert(stype == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
21843
21844 assert(val->sType == stype);
21845 vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext(dec, val->pNext);
21846 vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(dec, val);
21847 }
21848
21849 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(const void * val)21850 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(const void *val)
21851 {
21852 /* no known/supported struct */
21853 return vn_sizeof_simple_pointer(NULL);
21854 }
21855
21856 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial(const VkSamplerYcbcrConversionImageFormatProperties * val)21857 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial(const VkSamplerYcbcrConversionImageFormatProperties *val)
21858 {
21859 size_t size = 0;
21860 /* skip val->{sType,pNext} */
21861 /* skip val->combinedImageSamplerDescriptorCount */
21862 return size;
21863 }
21864
21865 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_partial(const VkSamplerYcbcrConversionImageFormatProperties * val)21866 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_partial(const VkSamplerYcbcrConversionImageFormatProperties *val)
21867 {
21868 size_t size = 0;
21869
21870 size += vn_sizeof_VkStructureType(&val->sType);
21871 size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(val->pNext);
21872 size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial(val);
21873
21874 return size;
21875 }
21876
21877 static inline void
vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)21878 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
21879 {
21880 /* no known/supported struct */
21881 vn_encode_simple_pointer(enc, NULL);
21882 }
21883
21884 static inline void
vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(struct vn_cs_encoder * enc,const VkSamplerYcbcrConversionImageFormatProperties * val)21885 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionImageFormatProperties *val)
21886 {
21887 /* skip val->{sType,pNext} */
21888 /* skip val->combinedImageSamplerDescriptorCount */
21889 }
21890
21891 static inline void
vn_encode_VkSamplerYcbcrConversionImageFormatProperties_partial(struct vn_cs_encoder * enc,const VkSamplerYcbcrConversionImageFormatProperties * val)21892 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionImageFormatProperties *val)
21893 {
21894 assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
21895 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES });
21896 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(enc, val->pNext);
21897 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(enc, val);
21898 }
21899
21900 /* struct VkImageFormatProperties2 chain */
21901
21902 static inline size_t
vn_sizeof_VkImageFormatProperties2_pnext(const void * val)21903 vn_sizeof_VkImageFormatProperties2_pnext(const void *val)
21904 {
21905 const VkBaseInStructure *pnext = val;
21906 size_t size = 0;
21907
21908 while (pnext) {
21909 switch ((int32_t)pnext->sType) {
21910 case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
21911 size += vn_sizeof_simple_pointer(pnext);
21912 size += vn_sizeof_VkStructureType(&pnext->sType);
21913 size += vn_sizeof_VkImageFormatProperties2_pnext(pnext->pNext);
21914 size += vn_sizeof_VkExternalImageFormatProperties_self((const VkExternalImageFormatProperties *)pnext);
21915 return size;
21916 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
21917 size += vn_sizeof_simple_pointer(pnext);
21918 size += vn_sizeof_VkStructureType(&pnext->sType);
21919 size += vn_sizeof_VkImageFormatProperties2_pnext(pnext->pNext);
21920 size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self((const VkSamplerYcbcrConversionImageFormatProperties *)pnext);
21921 return size;
21922 default:
21923 /* ignore unknown/unsupported struct */
21924 break;
21925 }
21926 pnext = pnext->pNext;
21927 }
21928
21929 return vn_sizeof_simple_pointer(NULL);
21930 }
21931
21932 static inline size_t
vn_sizeof_VkImageFormatProperties2_self(const VkImageFormatProperties2 * val)21933 vn_sizeof_VkImageFormatProperties2_self(const VkImageFormatProperties2 *val)
21934 {
21935 size_t size = 0;
21936 /* skip val->{sType,pNext} */
21937 size += vn_sizeof_VkImageFormatProperties(&val->imageFormatProperties);
21938 return size;
21939 }
21940
21941 static inline size_t
vn_sizeof_VkImageFormatProperties2(const VkImageFormatProperties2 * val)21942 vn_sizeof_VkImageFormatProperties2(const VkImageFormatProperties2 *val)
21943 {
21944 size_t size = 0;
21945
21946 size += vn_sizeof_VkStructureType(&val->sType);
21947 size += vn_sizeof_VkImageFormatProperties2_pnext(val->pNext);
21948 size += vn_sizeof_VkImageFormatProperties2_self(val);
21949
21950 return size;
21951 }
21952
21953 static inline void
vn_decode_VkImageFormatProperties2_pnext(struct vn_cs_decoder * dec,const void * val)21954 vn_decode_VkImageFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
21955 {
21956 VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
21957 VkStructureType stype;
21958
21959 if (!vn_decode_simple_pointer(dec))
21960 return;
21961
21962 vn_decode_VkStructureType(dec, &stype);
21963 while (true) {
21964 assert(pnext);
21965 if (pnext->sType == stype)
21966 break;
21967
21968 pnext = pnext->pNext;
21969 }
21970
21971 switch ((int32_t)pnext->sType) {
21972 case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
21973 vn_decode_VkImageFormatProperties2_pnext(dec, pnext->pNext);
21974 vn_decode_VkExternalImageFormatProperties_self(dec, (VkExternalImageFormatProperties *)pnext);
21975 break;
21976 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
21977 vn_decode_VkImageFormatProperties2_pnext(dec, pnext->pNext);
21978 vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(dec, (VkSamplerYcbcrConversionImageFormatProperties *)pnext);
21979 break;
21980 default:
21981 assert(false);
21982 break;
21983 }
21984 }
21985
21986 static inline void
vn_decode_VkImageFormatProperties2_self(struct vn_cs_decoder * dec,VkImageFormatProperties2 * val)21987 vn_decode_VkImageFormatProperties2_self(struct vn_cs_decoder *dec, VkImageFormatProperties2 *val)
21988 {
21989 /* skip val->{sType,pNext} */
21990 vn_decode_VkImageFormatProperties(dec, &val->imageFormatProperties);
21991 }
21992
21993 static inline void
vn_decode_VkImageFormatProperties2(struct vn_cs_decoder * dec,VkImageFormatProperties2 * val)21994 vn_decode_VkImageFormatProperties2(struct vn_cs_decoder *dec, VkImageFormatProperties2 *val)
21995 {
21996 VkStructureType stype;
21997 vn_decode_VkStructureType(dec, &stype);
21998 assert(stype == VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2);
21999
22000 assert(val->sType == stype);
22001 vn_decode_VkImageFormatProperties2_pnext(dec, val->pNext);
22002 vn_decode_VkImageFormatProperties2_self(dec, val);
22003 }
22004
22005 static inline size_t
vn_sizeof_VkImageFormatProperties2_pnext_partial(const void * val)22006 vn_sizeof_VkImageFormatProperties2_pnext_partial(const void *val)
22007 {
22008 const VkBaseInStructure *pnext = val;
22009 size_t size = 0;
22010
22011 while (pnext) {
22012 switch ((int32_t)pnext->sType) {
22013 case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
22014 size += vn_sizeof_simple_pointer(pnext);
22015 size += vn_sizeof_VkStructureType(&pnext->sType);
22016 size += vn_sizeof_VkImageFormatProperties2_pnext_partial(pnext->pNext);
22017 size += vn_sizeof_VkExternalImageFormatProperties_self_partial((const VkExternalImageFormatProperties *)pnext);
22018 return size;
22019 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
22020 size += vn_sizeof_simple_pointer(pnext);
22021 size += vn_sizeof_VkStructureType(&pnext->sType);
22022 size += vn_sizeof_VkImageFormatProperties2_pnext_partial(pnext->pNext);
22023 size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial((const VkSamplerYcbcrConversionImageFormatProperties *)pnext);
22024 return size;
22025 default:
22026 /* ignore unknown/unsupported struct */
22027 break;
22028 }
22029 pnext = pnext->pNext;
22030 }
22031
22032 return vn_sizeof_simple_pointer(NULL);
22033 }
22034
22035 static inline size_t
vn_sizeof_VkImageFormatProperties2_self_partial(const VkImageFormatProperties2 * val)22036 vn_sizeof_VkImageFormatProperties2_self_partial(const VkImageFormatProperties2 *val)
22037 {
22038 size_t size = 0;
22039 /* skip val->{sType,pNext} */
22040 size += vn_sizeof_VkImageFormatProperties_partial(&val->imageFormatProperties);
22041 return size;
22042 }
22043
22044 static inline size_t
vn_sizeof_VkImageFormatProperties2_partial(const VkImageFormatProperties2 * val)22045 vn_sizeof_VkImageFormatProperties2_partial(const VkImageFormatProperties2 *val)
22046 {
22047 size_t size = 0;
22048
22049 size += vn_sizeof_VkStructureType(&val->sType);
22050 size += vn_sizeof_VkImageFormatProperties2_pnext_partial(val->pNext);
22051 size += vn_sizeof_VkImageFormatProperties2_self_partial(val);
22052
22053 return size;
22054 }
22055
22056 static inline void
vn_encode_VkImageFormatProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)22057 vn_encode_VkImageFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
22058 {
22059 const VkBaseInStructure *pnext = val;
22060
22061 while (pnext) {
22062 switch ((int32_t)pnext->sType) {
22063 case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
22064 vn_encode_simple_pointer(enc, pnext);
22065 vn_encode_VkStructureType(enc, &pnext->sType);
22066 vn_encode_VkImageFormatProperties2_pnext_partial(enc, pnext->pNext);
22067 vn_encode_VkExternalImageFormatProperties_self_partial(enc, (const VkExternalImageFormatProperties *)pnext);
22068 return;
22069 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
22070 vn_encode_simple_pointer(enc, pnext);
22071 vn_encode_VkStructureType(enc, &pnext->sType);
22072 vn_encode_VkImageFormatProperties2_pnext_partial(enc, pnext->pNext);
22073 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(enc, (const VkSamplerYcbcrConversionImageFormatProperties *)pnext);
22074 return;
22075 default:
22076 /* ignore unknown/unsupported struct */
22077 break;
22078 }
22079 pnext = pnext->pNext;
22080 }
22081
22082 vn_encode_simple_pointer(enc, NULL);
22083 }
22084
22085 static inline void
vn_encode_VkImageFormatProperties2_self_partial(struct vn_cs_encoder * enc,const VkImageFormatProperties2 * val)22086 vn_encode_VkImageFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkImageFormatProperties2 *val)
22087 {
22088 /* skip val->{sType,pNext} */
22089 vn_encode_VkImageFormatProperties_partial(enc, &val->imageFormatProperties);
22090 }
22091
22092 static inline void
vn_encode_VkImageFormatProperties2_partial(struct vn_cs_encoder * enc,const VkImageFormatProperties2 * val)22093 vn_encode_VkImageFormatProperties2_partial(struct vn_cs_encoder *enc, const VkImageFormatProperties2 *val)
22094 {
22095 assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2);
22096 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 });
22097 vn_encode_VkImageFormatProperties2_pnext_partial(enc, val->pNext);
22098 vn_encode_VkImageFormatProperties2_self_partial(enc, val);
22099 }
22100
22101 /* struct VkQueueFamilyProperties2 chain */
22102
22103 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_pnext(const void * val)22104 vn_sizeof_VkQueueFamilyProperties2_pnext(const void *val)
22105 {
22106 /* no known/supported struct */
22107 return vn_sizeof_simple_pointer(NULL);
22108 }
22109
22110 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_self(const VkQueueFamilyProperties2 * val)22111 vn_sizeof_VkQueueFamilyProperties2_self(const VkQueueFamilyProperties2 *val)
22112 {
22113 size_t size = 0;
22114 /* skip val->{sType,pNext} */
22115 size += vn_sizeof_VkQueueFamilyProperties(&val->queueFamilyProperties);
22116 return size;
22117 }
22118
22119 static inline size_t
vn_sizeof_VkQueueFamilyProperties2(const VkQueueFamilyProperties2 * val)22120 vn_sizeof_VkQueueFamilyProperties2(const VkQueueFamilyProperties2 *val)
22121 {
22122 size_t size = 0;
22123
22124 size += vn_sizeof_VkStructureType(&val->sType);
22125 size += vn_sizeof_VkQueueFamilyProperties2_pnext(val->pNext);
22126 size += vn_sizeof_VkQueueFamilyProperties2_self(val);
22127
22128 return size;
22129 }
22130
22131 static inline void
vn_decode_VkQueueFamilyProperties2_pnext(struct vn_cs_decoder * dec,const void * val)22132 vn_decode_VkQueueFamilyProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
22133 {
22134 /* no known/supported struct */
22135 if (vn_decode_simple_pointer(dec))
22136 assert(false);
22137 }
22138
22139 static inline void
vn_decode_VkQueueFamilyProperties2_self(struct vn_cs_decoder * dec,VkQueueFamilyProperties2 * val)22140 vn_decode_VkQueueFamilyProperties2_self(struct vn_cs_decoder *dec, VkQueueFamilyProperties2 *val)
22141 {
22142 /* skip val->{sType,pNext} */
22143 vn_decode_VkQueueFamilyProperties(dec, &val->queueFamilyProperties);
22144 }
22145
22146 static inline void
vn_decode_VkQueueFamilyProperties2(struct vn_cs_decoder * dec,VkQueueFamilyProperties2 * val)22147 vn_decode_VkQueueFamilyProperties2(struct vn_cs_decoder *dec, VkQueueFamilyProperties2 *val)
22148 {
22149 VkStructureType stype;
22150 vn_decode_VkStructureType(dec, &stype);
22151 assert(stype == VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2);
22152
22153 assert(val->sType == stype);
22154 vn_decode_VkQueueFamilyProperties2_pnext(dec, val->pNext);
22155 vn_decode_VkQueueFamilyProperties2_self(dec, val);
22156 }
22157
22158 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_pnext_partial(const void * val)22159 vn_sizeof_VkQueueFamilyProperties2_pnext_partial(const void *val)
22160 {
22161 /* no known/supported struct */
22162 return vn_sizeof_simple_pointer(NULL);
22163 }
22164
22165 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_self_partial(const VkQueueFamilyProperties2 * val)22166 vn_sizeof_VkQueueFamilyProperties2_self_partial(const VkQueueFamilyProperties2 *val)
22167 {
22168 size_t size = 0;
22169 /* skip val->{sType,pNext} */
22170 size += vn_sizeof_VkQueueFamilyProperties_partial(&val->queueFamilyProperties);
22171 return size;
22172 }
22173
22174 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_partial(const VkQueueFamilyProperties2 * val)22175 vn_sizeof_VkQueueFamilyProperties2_partial(const VkQueueFamilyProperties2 *val)
22176 {
22177 size_t size = 0;
22178
22179 size += vn_sizeof_VkStructureType(&val->sType);
22180 size += vn_sizeof_VkQueueFamilyProperties2_pnext_partial(val->pNext);
22181 size += vn_sizeof_VkQueueFamilyProperties2_self_partial(val);
22182
22183 return size;
22184 }
22185
22186 static inline void
vn_encode_VkQueueFamilyProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)22187 vn_encode_VkQueueFamilyProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
22188 {
22189 /* no known/supported struct */
22190 vn_encode_simple_pointer(enc, NULL);
22191 }
22192
22193 static inline void
vn_encode_VkQueueFamilyProperties2_self_partial(struct vn_cs_encoder * enc,const VkQueueFamilyProperties2 * val)22194 vn_encode_VkQueueFamilyProperties2_self_partial(struct vn_cs_encoder *enc, const VkQueueFamilyProperties2 *val)
22195 {
22196 /* skip val->{sType,pNext} */
22197 vn_encode_VkQueueFamilyProperties_partial(enc, &val->queueFamilyProperties);
22198 }
22199
22200 static inline void
vn_encode_VkQueueFamilyProperties2_partial(struct vn_cs_encoder * enc,const VkQueueFamilyProperties2 * val)22201 vn_encode_VkQueueFamilyProperties2_partial(struct vn_cs_encoder *enc, const VkQueueFamilyProperties2 *val)
22202 {
22203 assert(val->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2);
22204 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 });
22205 vn_encode_VkQueueFamilyProperties2_pnext_partial(enc, val->pNext);
22206 vn_encode_VkQueueFamilyProperties2_self_partial(enc, val);
22207 }
22208
22209 /* struct VkPhysicalDeviceMemoryBudgetPropertiesEXT chain */
22210
22211 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryBudgetPropertiesEXT_pnext(const void * val)22212 vn_sizeof_VkPhysicalDeviceMemoryBudgetPropertiesEXT_pnext(const void *val)
22213 {
22214 /* no known/supported struct */
22215 return vn_sizeof_simple_pointer(NULL);
22216 }
22217
22218 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryBudgetPropertiesEXT_self(const VkPhysicalDeviceMemoryBudgetPropertiesEXT * val)22219 vn_sizeof_VkPhysicalDeviceMemoryBudgetPropertiesEXT_self(const VkPhysicalDeviceMemoryBudgetPropertiesEXT *val)
22220 {
22221 size_t size = 0;
22222 /* skip val->{sType,pNext} */
22223 size += vn_sizeof_array_size(VK_MAX_MEMORY_HEAPS);
22224 size += vn_sizeof_VkDeviceSize_array(val->heapBudget, VK_MAX_MEMORY_HEAPS);
22225 size += vn_sizeof_array_size(VK_MAX_MEMORY_HEAPS);
22226 size += vn_sizeof_VkDeviceSize_array(val->heapUsage, VK_MAX_MEMORY_HEAPS);
22227 return size;
22228 }
22229
22230 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const VkPhysicalDeviceMemoryBudgetPropertiesEXT * val)22231 vn_sizeof_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const VkPhysicalDeviceMemoryBudgetPropertiesEXT *val)
22232 {
22233 size_t size = 0;
22234
22235 size += vn_sizeof_VkStructureType(&val->sType);
22236 size += vn_sizeof_VkPhysicalDeviceMemoryBudgetPropertiesEXT_pnext(val->pNext);
22237 size += vn_sizeof_VkPhysicalDeviceMemoryBudgetPropertiesEXT_self(val);
22238
22239 return size;
22240 }
22241
22242 static inline void
vn_decode_VkPhysicalDeviceMemoryBudgetPropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)22243 vn_decode_VkPhysicalDeviceMemoryBudgetPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
22244 {
22245 /* no known/supported struct */
22246 if (vn_decode_simple_pointer(dec))
22247 assert(false);
22248 }
22249
22250 static inline void
vn_decode_VkPhysicalDeviceMemoryBudgetPropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMemoryBudgetPropertiesEXT * val)22251 vn_decode_VkPhysicalDeviceMemoryBudgetPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryBudgetPropertiesEXT *val)
22252 {
22253 /* skip val->{sType,pNext} */
22254 {
22255 const size_t array_size = vn_decode_array_size(dec, VK_MAX_MEMORY_HEAPS);
22256 vn_decode_VkDeviceSize_array(dec, val->heapBudget, array_size);
22257 }
22258 {
22259 const size_t array_size = vn_decode_array_size(dec, VK_MAX_MEMORY_HEAPS);
22260 vn_decode_VkDeviceSize_array(dec, val->heapUsage, array_size);
22261 }
22262 }
22263
22264 static inline void
vn_decode_VkPhysicalDeviceMemoryBudgetPropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceMemoryBudgetPropertiesEXT * val)22265 vn_decode_VkPhysicalDeviceMemoryBudgetPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryBudgetPropertiesEXT *val)
22266 {
22267 VkStructureType stype;
22268 vn_decode_VkStructureType(dec, &stype);
22269 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT);
22270
22271 assert(val->sType == stype);
22272 vn_decode_VkPhysicalDeviceMemoryBudgetPropertiesEXT_pnext(dec, val->pNext);
22273 vn_decode_VkPhysicalDeviceMemoryBudgetPropertiesEXT_self(dec, val);
22274 }
22275
22276 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryBudgetPropertiesEXT_pnext_partial(const void * val)22277 vn_sizeof_VkPhysicalDeviceMemoryBudgetPropertiesEXT_pnext_partial(const void *val)
22278 {
22279 /* no known/supported struct */
22280 return vn_sizeof_simple_pointer(NULL);
22281 }
22282
22283 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryBudgetPropertiesEXT_self_partial(const VkPhysicalDeviceMemoryBudgetPropertiesEXT * val)22284 vn_sizeof_VkPhysicalDeviceMemoryBudgetPropertiesEXT_self_partial(const VkPhysicalDeviceMemoryBudgetPropertiesEXT *val)
22285 {
22286 size_t size = 0;
22287 /* skip val->{sType,pNext} */
22288 /* skip val->heapBudget */
22289 /* skip val->heapUsage */
22290 return size;
22291 }
22292
22293 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryBudgetPropertiesEXT_partial(const VkPhysicalDeviceMemoryBudgetPropertiesEXT * val)22294 vn_sizeof_VkPhysicalDeviceMemoryBudgetPropertiesEXT_partial(const VkPhysicalDeviceMemoryBudgetPropertiesEXT *val)
22295 {
22296 size_t size = 0;
22297
22298 size += vn_sizeof_VkStructureType(&val->sType);
22299 size += vn_sizeof_VkPhysicalDeviceMemoryBudgetPropertiesEXT_pnext_partial(val->pNext);
22300 size += vn_sizeof_VkPhysicalDeviceMemoryBudgetPropertiesEXT_self_partial(val);
22301
22302 return size;
22303 }
22304
22305 static inline void
vn_encode_VkPhysicalDeviceMemoryBudgetPropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)22306 vn_encode_VkPhysicalDeviceMemoryBudgetPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
22307 {
22308 /* no known/supported struct */
22309 vn_encode_simple_pointer(enc, NULL);
22310 }
22311
22312 static inline void
vn_encode_VkPhysicalDeviceMemoryBudgetPropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMemoryBudgetPropertiesEXT * val)22313 vn_encode_VkPhysicalDeviceMemoryBudgetPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryBudgetPropertiesEXT *val)
22314 {
22315 /* skip val->{sType,pNext} */
22316 /* skip val->heapBudget */
22317 /* skip val->heapUsage */
22318 }
22319
22320 static inline void
vn_encode_VkPhysicalDeviceMemoryBudgetPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMemoryBudgetPropertiesEXT * val)22321 vn_encode_VkPhysicalDeviceMemoryBudgetPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryBudgetPropertiesEXT *val)
22322 {
22323 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT);
22324 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT });
22325 vn_encode_VkPhysicalDeviceMemoryBudgetPropertiesEXT_pnext_partial(enc, val->pNext);
22326 vn_encode_VkPhysicalDeviceMemoryBudgetPropertiesEXT_self_partial(enc, val);
22327 }
22328
22329 /* struct VkPhysicalDeviceMemoryProperties2 chain */
22330
22331 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext(const void * val)22332 vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext(const void *val)
22333 {
22334 const VkBaseInStructure *pnext = val;
22335 size_t size = 0;
22336
22337 while (pnext) {
22338 switch ((int32_t)pnext->sType) {
22339 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
22340 if (!vn_cs_renderer_protocol_has_extension(238 /* VK_EXT_memory_budget */))
22341 break;
22342 size += vn_sizeof_simple_pointer(pnext);
22343 size += vn_sizeof_VkStructureType(&pnext->sType);
22344 size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext(pnext->pNext);
22345 size += vn_sizeof_VkPhysicalDeviceMemoryBudgetPropertiesEXT_self((const VkPhysicalDeviceMemoryBudgetPropertiesEXT *)pnext);
22346 return size;
22347 default:
22348 /* ignore unknown/unsupported struct */
22349 break;
22350 }
22351 pnext = pnext->pNext;
22352 }
22353
22354 return vn_sizeof_simple_pointer(NULL);
22355 }
22356
22357 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_self(const VkPhysicalDeviceMemoryProperties2 * val)22358 vn_sizeof_VkPhysicalDeviceMemoryProperties2_self(const VkPhysicalDeviceMemoryProperties2 *val)
22359 {
22360 size_t size = 0;
22361 /* skip val->{sType,pNext} */
22362 size += vn_sizeof_VkPhysicalDeviceMemoryProperties(&val->memoryProperties);
22363 return size;
22364 }
22365
22366 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2 * val)22367 vn_sizeof_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2 *val)
22368 {
22369 size_t size = 0;
22370
22371 size += vn_sizeof_VkStructureType(&val->sType);
22372 size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext(val->pNext);
22373 size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_self(val);
22374
22375 return size;
22376 }
22377
22378 static inline void
vn_decode_VkPhysicalDeviceMemoryProperties2_pnext(struct vn_cs_decoder * dec,const void * val)22379 vn_decode_VkPhysicalDeviceMemoryProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
22380 {
22381 VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
22382 VkStructureType stype;
22383
22384 if (!vn_decode_simple_pointer(dec))
22385 return;
22386
22387 vn_decode_VkStructureType(dec, &stype);
22388 while (true) {
22389 assert(pnext);
22390 if (pnext->sType == stype)
22391 break;
22392
22393 pnext = pnext->pNext;
22394 }
22395
22396 switch ((int32_t)pnext->sType) {
22397 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
22398 vn_decode_VkPhysicalDeviceMemoryProperties2_pnext(dec, pnext->pNext);
22399 vn_decode_VkPhysicalDeviceMemoryBudgetPropertiesEXT_self(dec, (VkPhysicalDeviceMemoryBudgetPropertiesEXT *)pnext);
22400 break;
22401 default:
22402 assert(false);
22403 break;
22404 }
22405 }
22406
22407 static inline void
vn_decode_VkPhysicalDeviceMemoryProperties2_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMemoryProperties2 * val)22408 vn_decode_VkPhysicalDeviceMemoryProperties2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties2 *val)
22409 {
22410 /* skip val->{sType,pNext} */
22411 vn_decode_VkPhysicalDeviceMemoryProperties(dec, &val->memoryProperties);
22412 }
22413
22414 static inline void
vn_decode_VkPhysicalDeviceMemoryProperties2(struct vn_cs_decoder * dec,VkPhysicalDeviceMemoryProperties2 * val)22415 vn_decode_VkPhysicalDeviceMemoryProperties2(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties2 *val)
22416 {
22417 VkStructureType stype;
22418 vn_decode_VkStructureType(dec, &stype);
22419 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2);
22420
22421 assert(val->sType == stype);
22422 vn_decode_VkPhysicalDeviceMemoryProperties2_pnext(dec, val->pNext);
22423 vn_decode_VkPhysicalDeviceMemoryProperties2_self(dec, val);
22424 }
22425
22426 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext_partial(const void * val)22427 vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext_partial(const void *val)
22428 {
22429 const VkBaseInStructure *pnext = val;
22430 size_t size = 0;
22431
22432 while (pnext) {
22433 switch ((int32_t)pnext->sType) {
22434 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
22435 if (!vn_cs_renderer_protocol_has_extension(238 /* VK_EXT_memory_budget */))
22436 break;
22437 size += vn_sizeof_simple_pointer(pnext);
22438 size += vn_sizeof_VkStructureType(&pnext->sType);
22439 size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext_partial(pnext->pNext);
22440 size += vn_sizeof_VkPhysicalDeviceMemoryBudgetPropertiesEXT_self_partial((const VkPhysicalDeviceMemoryBudgetPropertiesEXT *)pnext);
22441 return size;
22442 default:
22443 /* ignore unknown/unsupported struct */
22444 break;
22445 }
22446 pnext = pnext->pNext;
22447 }
22448
22449 return vn_sizeof_simple_pointer(NULL);
22450 }
22451
22452 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_self_partial(const VkPhysicalDeviceMemoryProperties2 * val)22453 vn_sizeof_VkPhysicalDeviceMemoryProperties2_self_partial(const VkPhysicalDeviceMemoryProperties2 *val)
22454 {
22455 size_t size = 0;
22456 /* skip val->{sType,pNext} */
22457 size += vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(&val->memoryProperties);
22458 return size;
22459 }
22460
22461 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_partial(const VkPhysicalDeviceMemoryProperties2 * val)22462 vn_sizeof_VkPhysicalDeviceMemoryProperties2_partial(const VkPhysicalDeviceMemoryProperties2 *val)
22463 {
22464 size_t size = 0;
22465
22466 size += vn_sizeof_VkStructureType(&val->sType);
22467 size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext_partial(val->pNext);
22468 size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_self_partial(val);
22469
22470 return size;
22471 }
22472
22473 static inline void
vn_encode_VkPhysicalDeviceMemoryProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)22474 vn_encode_VkPhysicalDeviceMemoryProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
22475 {
22476 const VkBaseInStructure *pnext = val;
22477
22478 while (pnext) {
22479 switch ((int32_t)pnext->sType) {
22480 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
22481 if (!vn_cs_renderer_protocol_has_extension(238 /* VK_EXT_memory_budget */))
22482 break;
22483 vn_encode_simple_pointer(enc, pnext);
22484 vn_encode_VkStructureType(enc, &pnext->sType);
22485 vn_encode_VkPhysicalDeviceMemoryProperties2_pnext_partial(enc, pnext->pNext);
22486 vn_encode_VkPhysicalDeviceMemoryBudgetPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceMemoryBudgetPropertiesEXT *)pnext);
22487 return;
22488 default:
22489 /* ignore unknown/unsupported struct */
22490 break;
22491 }
22492 pnext = pnext->pNext;
22493 }
22494
22495 vn_encode_simple_pointer(enc, NULL);
22496 }
22497
22498 static inline void
vn_encode_VkPhysicalDeviceMemoryProperties2_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMemoryProperties2 * val)22499 vn_encode_VkPhysicalDeviceMemoryProperties2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties2 *val)
22500 {
22501 /* skip val->{sType,pNext} */
22502 vn_encode_VkPhysicalDeviceMemoryProperties_partial(enc, &val->memoryProperties);
22503 }
22504
22505 static inline void
vn_encode_VkPhysicalDeviceMemoryProperties2_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMemoryProperties2 * val)22506 vn_encode_VkPhysicalDeviceMemoryProperties2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties2 *val)
22507 {
22508 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2);
22509 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 });
22510 vn_encode_VkPhysicalDeviceMemoryProperties2_pnext_partial(enc, val->pNext);
22511 vn_encode_VkPhysicalDeviceMemoryProperties2_self_partial(enc, val);
22512 }
22513
22514 /* struct VkPhysicalDeviceSparseImageFormatInfo2 chain */
22515
22516 static inline size_t
vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_pnext(const void * val)22517 vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_pnext(const void *val)
22518 {
22519 /* no known/supported struct */
22520 return vn_sizeof_simple_pointer(NULL);
22521 }
22522
22523 static inline size_t
vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_self(const VkPhysicalDeviceSparseImageFormatInfo2 * val)22524 vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_self(const VkPhysicalDeviceSparseImageFormatInfo2 *val)
22525 {
22526 size_t size = 0;
22527 /* skip val->{sType,pNext} */
22528 size += vn_sizeof_VkFormat(&val->format);
22529 size += vn_sizeof_VkImageType(&val->type);
22530 size += vn_sizeof_VkSampleCountFlagBits(&val->samples);
22531 size += vn_sizeof_VkFlags(&val->usage);
22532 size += vn_sizeof_VkImageTiling(&val->tiling);
22533 return size;
22534 }
22535
22536 static inline size_t
vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2 * val)22537 vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2 *val)
22538 {
22539 size_t size = 0;
22540
22541 size += vn_sizeof_VkStructureType(&val->sType);
22542 size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_pnext(val->pNext);
22543 size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_self(val);
22544
22545 return size;
22546 }
22547
22548 static inline void
vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_pnext(struct vn_cs_encoder * enc,const void * val)22549 vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
22550 {
22551 /* no known/supported struct */
22552 vn_encode_simple_pointer(enc, NULL);
22553 }
22554
22555 static inline void
vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceSparseImageFormatInfo2 * val)22556 vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseImageFormatInfo2 *val)
22557 {
22558 /* skip val->{sType,pNext} */
22559 vn_encode_VkFormat(enc, &val->format);
22560 vn_encode_VkImageType(enc, &val->type);
22561 vn_encode_VkSampleCountFlagBits(enc, &val->samples);
22562 vn_encode_VkFlags(enc, &val->usage);
22563 vn_encode_VkImageTiling(enc, &val->tiling);
22564 }
22565
22566 static inline void
vn_encode_VkPhysicalDeviceSparseImageFormatInfo2(struct vn_cs_encoder * enc,const VkPhysicalDeviceSparseImageFormatInfo2 * val)22567 vn_encode_VkPhysicalDeviceSparseImageFormatInfo2(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseImageFormatInfo2 *val)
22568 {
22569 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2);
22570 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 });
22571 vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_pnext(enc, val->pNext);
22572 vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_self(enc, val);
22573 }
22574
22575 /* struct VkSparseImageFormatProperties2 chain */
22576
22577 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_pnext(const void * val)22578 vn_sizeof_VkSparseImageFormatProperties2_pnext(const void *val)
22579 {
22580 /* no known/supported struct */
22581 return vn_sizeof_simple_pointer(NULL);
22582 }
22583
22584 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_self(const VkSparseImageFormatProperties2 * val)22585 vn_sizeof_VkSparseImageFormatProperties2_self(const VkSparseImageFormatProperties2 *val)
22586 {
22587 size_t size = 0;
22588 /* skip val->{sType,pNext} */
22589 size += vn_sizeof_VkSparseImageFormatProperties(&val->properties);
22590 return size;
22591 }
22592
22593 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2 * val)22594 vn_sizeof_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2 *val)
22595 {
22596 size_t size = 0;
22597
22598 size += vn_sizeof_VkStructureType(&val->sType);
22599 size += vn_sizeof_VkSparseImageFormatProperties2_pnext(val->pNext);
22600 size += vn_sizeof_VkSparseImageFormatProperties2_self(val);
22601
22602 return size;
22603 }
22604
22605 static inline void
vn_decode_VkSparseImageFormatProperties2_pnext(struct vn_cs_decoder * dec,const void * val)22606 vn_decode_VkSparseImageFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
22607 {
22608 /* no known/supported struct */
22609 if (vn_decode_simple_pointer(dec))
22610 assert(false);
22611 }
22612
22613 static inline void
vn_decode_VkSparseImageFormatProperties2_self(struct vn_cs_decoder * dec,VkSparseImageFormatProperties2 * val)22614 vn_decode_VkSparseImageFormatProperties2_self(struct vn_cs_decoder *dec, VkSparseImageFormatProperties2 *val)
22615 {
22616 /* skip val->{sType,pNext} */
22617 vn_decode_VkSparseImageFormatProperties(dec, &val->properties);
22618 }
22619
22620 static inline void
vn_decode_VkSparseImageFormatProperties2(struct vn_cs_decoder * dec,VkSparseImageFormatProperties2 * val)22621 vn_decode_VkSparseImageFormatProperties2(struct vn_cs_decoder *dec, VkSparseImageFormatProperties2 *val)
22622 {
22623 VkStructureType stype;
22624 vn_decode_VkStructureType(dec, &stype);
22625 assert(stype == VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2);
22626
22627 assert(val->sType == stype);
22628 vn_decode_VkSparseImageFormatProperties2_pnext(dec, val->pNext);
22629 vn_decode_VkSparseImageFormatProperties2_self(dec, val);
22630 }
22631
22632 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_pnext_partial(const void * val)22633 vn_sizeof_VkSparseImageFormatProperties2_pnext_partial(const void *val)
22634 {
22635 /* no known/supported struct */
22636 return vn_sizeof_simple_pointer(NULL);
22637 }
22638
22639 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_self_partial(const VkSparseImageFormatProperties2 * val)22640 vn_sizeof_VkSparseImageFormatProperties2_self_partial(const VkSparseImageFormatProperties2 *val)
22641 {
22642 size_t size = 0;
22643 /* skip val->{sType,pNext} */
22644 size += vn_sizeof_VkSparseImageFormatProperties_partial(&val->properties);
22645 return size;
22646 }
22647
22648 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_partial(const VkSparseImageFormatProperties2 * val)22649 vn_sizeof_VkSparseImageFormatProperties2_partial(const VkSparseImageFormatProperties2 *val)
22650 {
22651 size_t size = 0;
22652
22653 size += vn_sizeof_VkStructureType(&val->sType);
22654 size += vn_sizeof_VkSparseImageFormatProperties2_pnext_partial(val->pNext);
22655 size += vn_sizeof_VkSparseImageFormatProperties2_self_partial(val);
22656
22657 return size;
22658 }
22659
22660 static inline void
vn_encode_VkSparseImageFormatProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)22661 vn_encode_VkSparseImageFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
22662 {
22663 /* no known/supported struct */
22664 vn_encode_simple_pointer(enc, NULL);
22665 }
22666
22667 static inline void
vn_encode_VkSparseImageFormatProperties2_self_partial(struct vn_cs_encoder * enc,const VkSparseImageFormatProperties2 * val)22668 vn_encode_VkSparseImageFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties2 *val)
22669 {
22670 /* skip val->{sType,pNext} */
22671 vn_encode_VkSparseImageFormatProperties_partial(enc, &val->properties);
22672 }
22673
22674 static inline void
vn_encode_VkSparseImageFormatProperties2_partial(struct vn_cs_encoder * enc,const VkSparseImageFormatProperties2 * val)22675 vn_encode_VkSparseImageFormatProperties2_partial(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties2 *val)
22676 {
22677 assert(val->sType == VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2);
22678 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 });
22679 vn_encode_VkSparseImageFormatProperties2_pnext_partial(enc, val->pNext);
22680 vn_encode_VkSparseImageFormatProperties2_self_partial(enc, val);
22681 }
22682
22683 /* struct VkPhysicalDeviceExternalBufferInfo chain */
22684
22685 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(const void * val)22686 vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(const void *val)
22687 {
22688 const VkBaseInStructure *pnext = val;
22689 size_t size = 0;
22690
22691 while (pnext) {
22692 switch ((int32_t)pnext->sType) {
22693 case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
22694 if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
22695 break;
22696 size += vn_sizeof_simple_pointer(pnext);
22697 size += vn_sizeof_VkStructureType(&pnext->sType);
22698 size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(pnext->pNext);
22699 size += vn_sizeof_VkBufferUsageFlags2CreateInfoKHR_self((const VkBufferUsageFlags2CreateInfoKHR *)pnext);
22700 return size;
22701 default:
22702 /* ignore unknown/unsupported struct */
22703 break;
22704 }
22705 pnext = pnext->pNext;
22706 }
22707
22708 return vn_sizeof_simple_pointer(NULL);
22709 }
22710
22711 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalBufferInfo_self(const VkPhysicalDeviceExternalBufferInfo * val)22712 vn_sizeof_VkPhysicalDeviceExternalBufferInfo_self(const VkPhysicalDeviceExternalBufferInfo *val)
22713 {
22714 size_t size = 0;
22715 /* skip val->{sType,pNext} */
22716 size += vn_sizeof_VkFlags(&val->flags);
22717 size += vn_sizeof_VkFlags(&val->usage);
22718 size += vn_sizeof_VkExternalMemoryHandleTypeFlagBits(&val->handleType);
22719 return size;
22720 }
22721
22722 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo * val)22723 vn_sizeof_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo *val)
22724 {
22725 size_t size = 0;
22726
22727 size += vn_sizeof_VkStructureType(&val->sType);
22728 size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(val->pNext);
22729 size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo_self(val);
22730
22731 return size;
22732 }
22733
22734 static inline void
vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(struct vn_cs_encoder * enc,const void * val)22735 vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(struct vn_cs_encoder *enc, const void *val)
22736 {
22737 const VkBaseInStructure *pnext = val;
22738
22739 while (pnext) {
22740 switch ((int32_t)pnext->sType) {
22741 case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
22742 if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
22743 break;
22744 vn_encode_simple_pointer(enc, pnext);
22745 vn_encode_VkStructureType(enc, &pnext->sType);
22746 vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(enc, pnext->pNext);
22747 vn_encode_VkBufferUsageFlags2CreateInfoKHR_self(enc, (const VkBufferUsageFlags2CreateInfoKHR *)pnext);
22748 return;
22749 default:
22750 /* ignore unknown/unsupported struct */
22751 break;
22752 }
22753 pnext = pnext->pNext;
22754 }
22755
22756 vn_encode_simple_pointer(enc, NULL);
22757 }
22758
22759 static inline void
vn_encode_VkPhysicalDeviceExternalBufferInfo_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalBufferInfo * val)22760 vn_encode_VkPhysicalDeviceExternalBufferInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalBufferInfo *val)
22761 {
22762 /* skip val->{sType,pNext} */
22763 vn_encode_VkFlags(enc, &val->flags);
22764 vn_encode_VkFlags(enc, &val->usage);
22765 vn_encode_VkExternalMemoryHandleTypeFlagBits(enc, &val->handleType);
22766 }
22767
22768 static inline void
vn_encode_VkPhysicalDeviceExternalBufferInfo(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalBufferInfo * val)22769 vn_encode_VkPhysicalDeviceExternalBufferInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalBufferInfo *val)
22770 {
22771 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO);
22772 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO });
22773 vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(enc, val->pNext);
22774 vn_encode_VkPhysicalDeviceExternalBufferInfo_self(enc, val);
22775 }
22776
22777 /* struct VkExternalBufferProperties chain */
22778
22779 static inline size_t
vn_sizeof_VkExternalBufferProperties_pnext(const void * val)22780 vn_sizeof_VkExternalBufferProperties_pnext(const void *val)
22781 {
22782 /* no known/supported struct */
22783 return vn_sizeof_simple_pointer(NULL);
22784 }
22785
22786 static inline size_t
vn_sizeof_VkExternalBufferProperties_self(const VkExternalBufferProperties * val)22787 vn_sizeof_VkExternalBufferProperties_self(const VkExternalBufferProperties *val)
22788 {
22789 size_t size = 0;
22790 /* skip val->{sType,pNext} */
22791 size += vn_sizeof_VkExternalMemoryProperties(&val->externalMemoryProperties);
22792 return size;
22793 }
22794
22795 static inline size_t
vn_sizeof_VkExternalBufferProperties(const VkExternalBufferProperties * val)22796 vn_sizeof_VkExternalBufferProperties(const VkExternalBufferProperties *val)
22797 {
22798 size_t size = 0;
22799
22800 size += vn_sizeof_VkStructureType(&val->sType);
22801 size += vn_sizeof_VkExternalBufferProperties_pnext(val->pNext);
22802 size += vn_sizeof_VkExternalBufferProperties_self(val);
22803
22804 return size;
22805 }
22806
22807 static inline void
vn_decode_VkExternalBufferProperties_pnext(struct vn_cs_decoder * dec,const void * val)22808 vn_decode_VkExternalBufferProperties_pnext(struct vn_cs_decoder *dec, const void *val)
22809 {
22810 /* no known/supported struct */
22811 if (vn_decode_simple_pointer(dec))
22812 assert(false);
22813 }
22814
22815 static inline void
vn_decode_VkExternalBufferProperties_self(struct vn_cs_decoder * dec,VkExternalBufferProperties * val)22816 vn_decode_VkExternalBufferProperties_self(struct vn_cs_decoder *dec, VkExternalBufferProperties *val)
22817 {
22818 /* skip val->{sType,pNext} */
22819 vn_decode_VkExternalMemoryProperties(dec, &val->externalMemoryProperties);
22820 }
22821
22822 static inline void
vn_decode_VkExternalBufferProperties(struct vn_cs_decoder * dec,VkExternalBufferProperties * val)22823 vn_decode_VkExternalBufferProperties(struct vn_cs_decoder *dec, VkExternalBufferProperties *val)
22824 {
22825 VkStructureType stype;
22826 vn_decode_VkStructureType(dec, &stype);
22827 assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES);
22828
22829 assert(val->sType == stype);
22830 vn_decode_VkExternalBufferProperties_pnext(dec, val->pNext);
22831 vn_decode_VkExternalBufferProperties_self(dec, val);
22832 }
22833
22834 static inline size_t
vn_sizeof_VkExternalBufferProperties_pnext_partial(const void * val)22835 vn_sizeof_VkExternalBufferProperties_pnext_partial(const void *val)
22836 {
22837 /* no known/supported struct */
22838 return vn_sizeof_simple_pointer(NULL);
22839 }
22840
22841 static inline size_t
vn_sizeof_VkExternalBufferProperties_self_partial(const VkExternalBufferProperties * val)22842 vn_sizeof_VkExternalBufferProperties_self_partial(const VkExternalBufferProperties *val)
22843 {
22844 size_t size = 0;
22845 /* skip val->{sType,pNext} */
22846 size += vn_sizeof_VkExternalMemoryProperties_partial(&val->externalMemoryProperties);
22847 return size;
22848 }
22849
22850 static inline size_t
vn_sizeof_VkExternalBufferProperties_partial(const VkExternalBufferProperties * val)22851 vn_sizeof_VkExternalBufferProperties_partial(const VkExternalBufferProperties *val)
22852 {
22853 size_t size = 0;
22854
22855 size += vn_sizeof_VkStructureType(&val->sType);
22856 size += vn_sizeof_VkExternalBufferProperties_pnext_partial(val->pNext);
22857 size += vn_sizeof_VkExternalBufferProperties_self_partial(val);
22858
22859 return size;
22860 }
22861
22862 static inline void
vn_encode_VkExternalBufferProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)22863 vn_encode_VkExternalBufferProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
22864 {
22865 /* no known/supported struct */
22866 vn_encode_simple_pointer(enc, NULL);
22867 }
22868
22869 static inline void
vn_encode_VkExternalBufferProperties_self_partial(struct vn_cs_encoder * enc,const VkExternalBufferProperties * val)22870 vn_encode_VkExternalBufferProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalBufferProperties *val)
22871 {
22872 /* skip val->{sType,pNext} */
22873 vn_encode_VkExternalMemoryProperties_partial(enc, &val->externalMemoryProperties);
22874 }
22875
22876 static inline void
vn_encode_VkExternalBufferProperties_partial(struct vn_cs_encoder * enc,const VkExternalBufferProperties * val)22877 vn_encode_VkExternalBufferProperties_partial(struct vn_cs_encoder *enc, const VkExternalBufferProperties *val)
22878 {
22879 assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES);
22880 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES });
22881 vn_encode_VkExternalBufferProperties_pnext_partial(enc, val->pNext);
22882 vn_encode_VkExternalBufferProperties_self_partial(enc, val);
22883 }
22884
22885 /* struct VkPhysicalDeviceExternalSemaphoreInfo chain */
22886
22887 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(const void * val)22888 vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(const void *val)
22889 {
22890 const VkBaseInStructure *pnext = val;
22891 size_t size = 0;
22892
22893 while (pnext) {
22894 switch ((int32_t)pnext->sType) {
22895 case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
22896 size += vn_sizeof_simple_pointer(pnext);
22897 size += vn_sizeof_VkStructureType(&pnext->sType);
22898 size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(pnext->pNext);
22899 size += vn_sizeof_VkSemaphoreTypeCreateInfo_self((const VkSemaphoreTypeCreateInfo *)pnext);
22900 return size;
22901 default:
22902 /* ignore unknown/unsupported struct */
22903 break;
22904 }
22905 pnext = pnext->pNext;
22906 }
22907
22908 return vn_sizeof_simple_pointer(NULL);
22909 }
22910
22911 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_self(const VkPhysicalDeviceExternalSemaphoreInfo * val)22912 vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_self(const VkPhysicalDeviceExternalSemaphoreInfo *val)
22913 {
22914 size_t size = 0;
22915 /* skip val->{sType,pNext} */
22916 size += vn_sizeof_VkExternalSemaphoreHandleTypeFlagBits(&val->handleType);
22917 return size;
22918 }
22919
22920 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo * val)22921 vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo *val)
22922 {
22923 size_t size = 0;
22924
22925 size += vn_sizeof_VkStructureType(&val->sType);
22926 size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(val->pNext);
22927 size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_self(val);
22928
22929 return size;
22930 }
22931
22932 static inline void
vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(struct vn_cs_encoder * enc,const void * val)22933 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(struct vn_cs_encoder *enc, const void *val)
22934 {
22935 const VkBaseInStructure *pnext = val;
22936
22937 while (pnext) {
22938 switch ((int32_t)pnext->sType) {
22939 case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
22940 vn_encode_simple_pointer(enc, pnext);
22941 vn_encode_VkStructureType(enc, &pnext->sType);
22942 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(enc, pnext->pNext);
22943 vn_encode_VkSemaphoreTypeCreateInfo_self(enc, (const VkSemaphoreTypeCreateInfo *)pnext);
22944 return;
22945 default:
22946 /* ignore unknown/unsupported struct */
22947 break;
22948 }
22949 pnext = pnext->pNext;
22950 }
22951
22952 vn_encode_simple_pointer(enc, NULL);
22953 }
22954
22955 static inline void
vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalSemaphoreInfo * val)22956 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalSemaphoreInfo *val)
22957 {
22958 /* skip val->{sType,pNext} */
22959 vn_encode_VkExternalSemaphoreHandleTypeFlagBits(enc, &val->handleType);
22960 }
22961
22962 static inline void
vn_encode_VkPhysicalDeviceExternalSemaphoreInfo(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalSemaphoreInfo * val)22963 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalSemaphoreInfo *val)
22964 {
22965 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO);
22966 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO });
22967 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(enc, val->pNext);
22968 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_self(enc, val);
22969 }
22970
22971 /* struct VkExternalSemaphoreProperties chain */
22972
22973 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_pnext(const void * val)22974 vn_sizeof_VkExternalSemaphoreProperties_pnext(const void *val)
22975 {
22976 /* no known/supported struct */
22977 return vn_sizeof_simple_pointer(NULL);
22978 }
22979
22980 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_self(const VkExternalSemaphoreProperties * val)22981 vn_sizeof_VkExternalSemaphoreProperties_self(const VkExternalSemaphoreProperties *val)
22982 {
22983 size_t size = 0;
22984 /* skip val->{sType,pNext} */
22985 size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes);
22986 size += vn_sizeof_VkFlags(&val->compatibleHandleTypes);
22987 size += vn_sizeof_VkFlags(&val->externalSemaphoreFeatures);
22988 return size;
22989 }
22990
22991 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties * val)22992 vn_sizeof_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties *val)
22993 {
22994 size_t size = 0;
22995
22996 size += vn_sizeof_VkStructureType(&val->sType);
22997 size += vn_sizeof_VkExternalSemaphoreProperties_pnext(val->pNext);
22998 size += vn_sizeof_VkExternalSemaphoreProperties_self(val);
22999
23000 return size;
23001 }
23002
23003 static inline void
vn_decode_VkExternalSemaphoreProperties_pnext(struct vn_cs_decoder * dec,const void * val)23004 vn_decode_VkExternalSemaphoreProperties_pnext(struct vn_cs_decoder *dec, const void *val)
23005 {
23006 /* no known/supported struct */
23007 if (vn_decode_simple_pointer(dec))
23008 assert(false);
23009 }
23010
23011 static inline void
vn_decode_VkExternalSemaphoreProperties_self(struct vn_cs_decoder * dec,VkExternalSemaphoreProperties * val)23012 vn_decode_VkExternalSemaphoreProperties_self(struct vn_cs_decoder *dec, VkExternalSemaphoreProperties *val)
23013 {
23014 /* skip val->{sType,pNext} */
23015 vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes);
23016 vn_decode_VkFlags(dec, &val->compatibleHandleTypes);
23017 vn_decode_VkFlags(dec, &val->externalSemaphoreFeatures);
23018 }
23019
23020 static inline void
vn_decode_VkExternalSemaphoreProperties(struct vn_cs_decoder * dec,VkExternalSemaphoreProperties * val)23021 vn_decode_VkExternalSemaphoreProperties(struct vn_cs_decoder *dec, VkExternalSemaphoreProperties *val)
23022 {
23023 VkStructureType stype;
23024 vn_decode_VkStructureType(dec, &stype);
23025 assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES);
23026
23027 assert(val->sType == stype);
23028 vn_decode_VkExternalSemaphoreProperties_pnext(dec, val->pNext);
23029 vn_decode_VkExternalSemaphoreProperties_self(dec, val);
23030 }
23031
23032 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_pnext_partial(const void * val)23033 vn_sizeof_VkExternalSemaphoreProperties_pnext_partial(const void *val)
23034 {
23035 /* no known/supported struct */
23036 return vn_sizeof_simple_pointer(NULL);
23037 }
23038
23039 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_self_partial(const VkExternalSemaphoreProperties * val)23040 vn_sizeof_VkExternalSemaphoreProperties_self_partial(const VkExternalSemaphoreProperties *val)
23041 {
23042 size_t size = 0;
23043 /* skip val->{sType,pNext} */
23044 /* skip val->exportFromImportedHandleTypes */
23045 /* skip val->compatibleHandleTypes */
23046 /* skip val->externalSemaphoreFeatures */
23047 return size;
23048 }
23049
23050 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_partial(const VkExternalSemaphoreProperties * val)23051 vn_sizeof_VkExternalSemaphoreProperties_partial(const VkExternalSemaphoreProperties *val)
23052 {
23053 size_t size = 0;
23054
23055 size += vn_sizeof_VkStructureType(&val->sType);
23056 size += vn_sizeof_VkExternalSemaphoreProperties_pnext_partial(val->pNext);
23057 size += vn_sizeof_VkExternalSemaphoreProperties_self_partial(val);
23058
23059 return size;
23060 }
23061
23062 static inline void
vn_encode_VkExternalSemaphoreProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)23063 vn_encode_VkExternalSemaphoreProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
23064 {
23065 /* no known/supported struct */
23066 vn_encode_simple_pointer(enc, NULL);
23067 }
23068
23069 static inline void
vn_encode_VkExternalSemaphoreProperties_self_partial(struct vn_cs_encoder * enc,const VkExternalSemaphoreProperties * val)23070 vn_encode_VkExternalSemaphoreProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalSemaphoreProperties *val)
23071 {
23072 /* skip val->{sType,pNext} */
23073 /* skip val->exportFromImportedHandleTypes */
23074 /* skip val->compatibleHandleTypes */
23075 /* skip val->externalSemaphoreFeatures */
23076 }
23077
23078 static inline void
vn_encode_VkExternalSemaphoreProperties_partial(struct vn_cs_encoder * enc,const VkExternalSemaphoreProperties * val)23079 vn_encode_VkExternalSemaphoreProperties_partial(struct vn_cs_encoder *enc, const VkExternalSemaphoreProperties *val)
23080 {
23081 assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES);
23082 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES });
23083 vn_encode_VkExternalSemaphoreProperties_pnext_partial(enc, val->pNext);
23084 vn_encode_VkExternalSemaphoreProperties_self_partial(enc, val);
23085 }
23086
23087 /* struct VkPhysicalDeviceExternalFenceInfo chain */
23088
23089 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalFenceInfo_pnext(const void * val)23090 vn_sizeof_VkPhysicalDeviceExternalFenceInfo_pnext(const void *val)
23091 {
23092 /* no known/supported struct */
23093 return vn_sizeof_simple_pointer(NULL);
23094 }
23095
23096 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalFenceInfo_self(const VkPhysicalDeviceExternalFenceInfo * val)23097 vn_sizeof_VkPhysicalDeviceExternalFenceInfo_self(const VkPhysicalDeviceExternalFenceInfo *val)
23098 {
23099 size_t size = 0;
23100 /* skip val->{sType,pNext} */
23101 size += vn_sizeof_VkExternalFenceHandleTypeFlagBits(&val->handleType);
23102 return size;
23103 }
23104
23105 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo * val)23106 vn_sizeof_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo *val)
23107 {
23108 size_t size = 0;
23109
23110 size += vn_sizeof_VkStructureType(&val->sType);
23111 size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo_pnext(val->pNext);
23112 size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo_self(val);
23113
23114 return size;
23115 }
23116
23117 static inline void
vn_encode_VkPhysicalDeviceExternalFenceInfo_pnext(struct vn_cs_encoder * enc,const void * val)23118 vn_encode_VkPhysicalDeviceExternalFenceInfo_pnext(struct vn_cs_encoder *enc, const void *val)
23119 {
23120 /* no known/supported struct */
23121 vn_encode_simple_pointer(enc, NULL);
23122 }
23123
23124 static inline void
vn_encode_VkPhysicalDeviceExternalFenceInfo_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalFenceInfo * val)23125 vn_encode_VkPhysicalDeviceExternalFenceInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalFenceInfo *val)
23126 {
23127 /* skip val->{sType,pNext} */
23128 vn_encode_VkExternalFenceHandleTypeFlagBits(enc, &val->handleType);
23129 }
23130
23131 static inline void
vn_encode_VkPhysicalDeviceExternalFenceInfo(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalFenceInfo * val)23132 vn_encode_VkPhysicalDeviceExternalFenceInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalFenceInfo *val)
23133 {
23134 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO);
23135 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO });
23136 vn_encode_VkPhysicalDeviceExternalFenceInfo_pnext(enc, val->pNext);
23137 vn_encode_VkPhysicalDeviceExternalFenceInfo_self(enc, val);
23138 }
23139
23140 /* struct VkExternalFenceProperties chain */
23141
23142 static inline size_t
vn_sizeof_VkExternalFenceProperties_pnext(const void * val)23143 vn_sizeof_VkExternalFenceProperties_pnext(const void *val)
23144 {
23145 /* no known/supported struct */
23146 return vn_sizeof_simple_pointer(NULL);
23147 }
23148
23149 static inline size_t
vn_sizeof_VkExternalFenceProperties_self(const VkExternalFenceProperties * val)23150 vn_sizeof_VkExternalFenceProperties_self(const VkExternalFenceProperties *val)
23151 {
23152 size_t size = 0;
23153 /* skip val->{sType,pNext} */
23154 size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes);
23155 size += vn_sizeof_VkFlags(&val->compatibleHandleTypes);
23156 size += vn_sizeof_VkFlags(&val->externalFenceFeatures);
23157 return size;
23158 }
23159
23160 static inline size_t
vn_sizeof_VkExternalFenceProperties(const VkExternalFenceProperties * val)23161 vn_sizeof_VkExternalFenceProperties(const VkExternalFenceProperties *val)
23162 {
23163 size_t size = 0;
23164
23165 size += vn_sizeof_VkStructureType(&val->sType);
23166 size += vn_sizeof_VkExternalFenceProperties_pnext(val->pNext);
23167 size += vn_sizeof_VkExternalFenceProperties_self(val);
23168
23169 return size;
23170 }
23171
23172 static inline void
vn_decode_VkExternalFenceProperties_pnext(struct vn_cs_decoder * dec,const void * val)23173 vn_decode_VkExternalFenceProperties_pnext(struct vn_cs_decoder *dec, const void *val)
23174 {
23175 /* no known/supported struct */
23176 if (vn_decode_simple_pointer(dec))
23177 assert(false);
23178 }
23179
23180 static inline void
vn_decode_VkExternalFenceProperties_self(struct vn_cs_decoder * dec,VkExternalFenceProperties * val)23181 vn_decode_VkExternalFenceProperties_self(struct vn_cs_decoder *dec, VkExternalFenceProperties *val)
23182 {
23183 /* skip val->{sType,pNext} */
23184 vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes);
23185 vn_decode_VkFlags(dec, &val->compatibleHandleTypes);
23186 vn_decode_VkFlags(dec, &val->externalFenceFeatures);
23187 }
23188
23189 static inline void
vn_decode_VkExternalFenceProperties(struct vn_cs_decoder * dec,VkExternalFenceProperties * val)23190 vn_decode_VkExternalFenceProperties(struct vn_cs_decoder *dec, VkExternalFenceProperties *val)
23191 {
23192 VkStructureType stype;
23193 vn_decode_VkStructureType(dec, &stype);
23194 assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES);
23195
23196 assert(val->sType == stype);
23197 vn_decode_VkExternalFenceProperties_pnext(dec, val->pNext);
23198 vn_decode_VkExternalFenceProperties_self(dec, val);
23199 }
23200
23201 static inline size_t
vn_sizeof_VkExternalFenceProperties_pnext_partial(const void * val)23202 vn_sizeof_VkExternalFenceProperties_pnext_partial(const void *val)
23203 {
23204 /* no known/supported struct */
23205 return vn_sizeof_simple_pointer(NULL);
23206 }
23207
23208 static inline size_t
vn_sizeof_VkExternalFenceProperties_self_partial(const VkExternalFenceProperties * val)23209 vn_sizeof_VkExternalFenceProperties_self_partial(const VkExternalFenceProperties *val)
23210 {
23211 size_t size = 0;
23212 /* skip val->{sType,pNext} */
23213 /* skip val->exportFromImportedHandleTypes */
23214 /* skip val->compatibleHandleTypes */
23215 /* skip val->externalFenceFeatures */
23216 return size;
23217 }
23218
23219 static inline size_t
vn_sizeof_VkExternalFenceProperties_partial(const VkExternalFenceProperties * val)23220 vn_sizeof_VkExternalFenceProperties_partial(const VkExternalFenceProperties *val)
23221 {
23222 size_t size = 0;
23223
23224 size += vn_sizeof_VkStructureType(&val->sType);
23225 size += vn_sizeof_VkExternalFenceProperties_pnext_partial(val->pNext);
23226 size += vn_sizeof_VkExternalFenceProperties_self_partial(val);
23227
23228 return size;
23229 }
23230
23231 static inline void
vn_encode_VkExternalFenceProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)23232 vn_encode_VkExternalFenceProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
23233 {
23234 /* no known/supported struct */
23235 vn_encode_simple_pointer(enc, NULL);
23236 }
23237
23238 static inline void
vn_encode_VkExternalFenceProperties_self_partial(struct vn_cs_encoder * enc,const VkExternalFenceProperties * val)23239 vn_encode_VkExternalFenceProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalFenceProperties *val)
23240 {
23241 /* skip val->{sType,pNext} */
23242 /* skip val->exportFromImportedHandleTypes */
23243 /* skip val->compatibleHandleTypes */
23244 /* skip val->externalFenceFeatures */
23245 }
23246
23247 static inline void
vn_encode_VkExternalFenceProperties_partial(struct vn_cs_encoder * enc,const VkExternalFenceProperties * val)23248 vn_encode_VkExternalFenceProperties_partial(struct vn_cs_encoder *enc, const VkExternalFenceProperties *val)
23249 {
23250 assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES);
23251 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES });
23252 vn_encode_VkExternalFenceProperties_pnext_partial(enc, val->pNext);
23253 vn_encode_VkExternalFenceProperties_self_partial(enc, val);
23254 }
23255
23256 /* struct VkPhysicalDeviceGroupProperties chain */
23257
23258 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_pnext(const void * val)23259 vn_sizeof_VkPhysicalDeviceGroupProperties_pnext(const void *val)
23260 {
23261 /* no known/supported struct */
23262 return vn_sizeof_simple_pointer(NULL);
23263 }
23264
23265 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_self(const VkPhysicalDeviceGroupProperties * val)23266 vn_sizeof_VkPhysicalDeviceGroupProperties_self(const VkPhysicalDeviceGroupProperties *val)
23267 {
23268 size_t size = 0;
23269 /* skip val->{sType,pNext} */
23270 size += vn_sizeof_uint32_t(&val->physicalDeviceCount);
23271 size += vn_sizeof_array_size(VK_MAX_DEVICE_GROUP_SIZE);
23272 for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
23273 size += vn_sizeof_VkPhysicalDevice(&val->physicalDevices[i]);
23274 size += vn_sizeof_VkBool32(&val->subsetAllocation);
23275 return size;
23276 }
23277
23278 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties * val)23279 vn_sizeof_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties *val)
23280 {
23281 size_t size = 0;
23282
23283 size += vn_sizeof_VkStructureType(&val->sType);
23284 size += vn_sizeof_VkPhysicalDeviceGroupProperties_pnext(val->pNext);
23285 size += vn_sizeof_VkPhysicalDeviceGroupProperties_self(val);
23286
23287 return size;
23288 }
23289
23290 static inline void
vn_decode_VkPhysicalDeviceGroupProperties_pnext(struct vn_cs_decoder * dec,const void * val)23291 vn_decode_VkPhysicalDeviceGroupProperties_pnext(struct vn_cs_decoder *dec, const void *val)
23292 {
23293 /* no known/supported struct */
23294 if (vn_decode_simple_pointer(dec))
23295 assert(false);
23296 }
23297
23298 static inline void
vn_decode_VkPhysicalDeviceGroupProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceGroupProperties * val)23299 vn_decode_VkPhysicalDeviceGroupProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceGroupProperties *val)
23300 {
23301 /* skip val->{sType,pNext} */
23302 vn_decode_uint32_t(dec, &val->physicalDeviceCount);
23303 {
23304 const uint32_t iter_count = vn_decode_array_size(dec, VK_MAX_DEVICE_GROUP_SIZE);
23305 for (uint32_t i = 0; i < iter_count; i++)
23306 vn_decode_VkPhysicalDevice(dec, &val->physicalDevices[i]);
23307 }
23308 vn_decode_VkBool32(dec, &val->subsetAllocation);
23309 }
23310
23311 static inline void
vn_decode_VkPhysicalDeviceGroupProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceGroupProperties * val)23312 vn_decode_VkPhysicalDeviceGroupProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceGroupProperties *val)
23313 {
23314 VkStructureType stype;
23315 vn_decode_VkStructureType(dec, &stype);
23316 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES);
23317
23318 assert(val->sType == stype);
23319 vn_decode_VkPhysicalDeviceGroupProperties_pnext(dec, val->pNext);
23320 vn_decode_VkPhysicalDeviceGroupProperties_self(dec, val);
23321 }
23322
23323 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_pnext_partial(const void * val)23324 vn_sizeof_VkPhysicalDeviceGroupProperties_pnext_partial(const void *val)
23325 {
23326 /* no known/supported struct */
23327 return vn_sizeof_simple_pointer(NULL);
23328 }
23329
23330 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_self_partial(const VkPhysicalDeviceGroupProperties * val)23331 vn_sizeof_VkPhysicalDeviceGroupProperties_self_partial(const VkPhysicalDeviceGroupProperties *val)
23332 {
23333 size_t size = 0;
23334 /* skip val->{sType,pNext} */
23335 /* skip val->physicalDeviceCount */
23336 size += vn_sizeof_array_size(VK_MAX_DEVICE_GROUP_SIZE);
23337 for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
23338 size += vn_sizeof_VkPhysicalDevice(&val->physicalDevices[i]);
23339 /* skip val->subsetAllocation */
23340 return size;
23341 }
23342
23343 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_partial(const VkPhysicalDeviceGroupProperties * val)23344 vn_sizeof_VkPhysicalDeviceGroupProperties_partial(const VkPhysicalDeviceGroupProperties *val)
23345 {
23346 size_t size = 0;
23347
23348 size += vn_sizeof_VkStructureType(&val->sType);
23349 size += vn_sizeof_VkPhysicalDeviceGroupProperties_pnext_partial(val->pNext);
23350 size += vn_sizeof_VkPhysicalDeviceGroupProperties_self_partial(val);
23351
23352 return size;
23353 }
23354
23355 static inline void
vn_encode_VkPhysicalDeviceGroupProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)23356 vn_encode_VkPhysicalDeviceGroupProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
23357 {
23358 /* no known/supported struct */
23359 vn_encode_simple_pointer(enc, NULL);
23360 }
23361
23362 static inline void
vn_encode_VkPhysicalDeviceGroupProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceGroupProperties * val)23363 vn_encode_VkPhysicalDeviceGroupProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceGroupProperties *val)
23364 {
23365 /* skip val->{sType,pNext} */
23366 /* skip val->physicalDeviceCount */
23367 vn_encode_array_size(enc, VK_MAX_DEVICE_GROUP_SIZE);
23368 for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
23369 vn_encode_VkPhysicalDevice(enc, &val->physicalDevices[i]);
23370 /* skip val->subsetAllocation */
23371 }
23372
23373 static inline void
vn_encode_VkPhysicalDeviceGroupProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceGroupProperties * val)23374 vn_encode_VkPhysicalDeviceGroupProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceGroupProperties *val)
23375 {
23376 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES);
23377 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES });
23378 vn_encode_VkPhysicalDeviceGroupProperties_pnext_partial(enc, val->pNext);
23379 vn_encode_VkPhysicalDeviceGroupProperties_self_partial(enc, val);
23380 }
23381
23382 /* struct VkDeviceQueueTimelineInfoMESA chain */
23383
23384 static inline size_t
vn_sizeof_VkDeviceQueueTimelineInfoMESA_pnext(const void * val)23385 vn_sizeof_VkDeviceQueueTimelineInfoMESA_pnext(const void *val)
23386 {
23387 /* no known/supported struct */
23388 return vn_sizeof_simple_pointer(NULL);
23389 }
23390
23391 static inline size_t
vn_sizeof_VkDeviceQueueTimelineInfoMESA_self(const VkDeviceQueueTimelineInfoMESA * val)23392 vn_sizeof_VkDeviceQueueTimelineInfoMESA_self(const VkDeviceQueueTimelineInfoMESA *val)
23393 {
23394 size_t size = 0;
23395 /* skip val->{sType,pNext} */
23396 size += vn_sizeof_uint32_t(&val->ringIdx);
23397 return size;
23398 }
23399
23400 static inline size_t
vn_sizeof_VkDeviceQueueTimelineInfoMESA(const VkDeviceQueueTimelineInfoMESA * val)23401 vn_sizeof_VkDeviceQueueTimelineInfoMESA(const VkDeviceQueueTimelineInfoMESA *val)
23402 {
23403 size_t size = 0;
23404
23405 size += vn_sizeof_VkStructureType(&val->sType);
23406 size += vn_sizeof_VkDeviceQueueTimelineInfoMESA_pnext(val->pNext);
23407 size += vn_sizeof_VkDeviceQueueTimelineInfoMESA_self(val);
23408
23409 return size;
23410 }
23411
23412 static inline void
vn_encode_VkDeviceQueueTimelineInfoMESA_pnext(struct vn_cs_encoder * enc,const void * val)23413 vn_encode_VkDeviceQueueTimelineInfoMESA_pnext(struct vn_cs_encoder *enc, const void *val)
23414 {
23415 /* no known/supported struct */
23416 vn_encode_simple_pointer(enc, NULL);
23417 }
23418
23419 static inline void
vn_encode_VkDeviceQueueTimelineInfoMESA_self(struct vn_cs_encoder * enc,const VkDeviceQueueTimelineInfoMESA * val)23420 vn_encode_VkDeviceQueueTimelineInfoMESA_self(struct vn_cs_encoder *enc, const VkDeviceQueueTimelineInfoMESA *val)
23421 {
23422 /* skip val->{sType,pNext} */
23423 vn_encode_uint32_t(enc, &val->ringIdx);
23424 }
23425
23426 static inline void
vn_encode_VkDeviceQueueTimelineInfoMESA(struct vn_cs_encoder * enc,const VkDeviceQueueTimelineInfoMESA * val)23427 vn_encode_VkDeviceQueueTimelineInfoMESA(struct vn_cs_encoder *enc, const VkDeviceQueueTimelineInfoMESA *val)
23428 {
23429 assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_QUEUE_TIMELINE_INFO_MESA);
23430 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_QUEUE_TIMELINE_INFO_MESA });
23431 vn_encode_VkDeviceQueueTimelineInfoMESA_pnext(enc, val->pNext);
23432 vn_encode_VkDeviceQueueTimelineInfoMESA_self(enc, val);
23433 }
23434
23435 /* struct VkDeviceQueueInfo2 chain */
23436
23437 static inline size_t
vn_sizeof_VkDeviceQueueInfo2_pnext(const void * val)23438 vn_sizeof_VkDeviceQueueInfo2_pnext(const void *val)
23439 {
23440 const VkBaseInStructure *pnext = val;
23441 size_t size = 0;
23442
23443 while (pnext) {
23444 switch ((int32_t)pnext->sType) {
23445 case VK_STRUCTURE_TYPE_DEVICE_QUEUE_TIMELINE_INFO_MESA:
23446 size += vn_sizeof_simple_pointer(pnext);
23447 size += vn_sizeof_VkStructureType(&pnext->sType);
23448 size += vn_sizeof_VkDeviceQueueInfo2_pnext(pnext->pNext);
23449 size += vn_sizeof_VkDeviceQueueTimelineInfoMESA_self((const VkDeviceQueueTimelineInfoMESA *)pnext);
23450 return size;
23451 default:
23452 /* ignore unknown/unsupported struct */
23453 break;
23454 }
23455 pnext = pnext->pNext;
23456 }
23457
23458 return vn_sizeof_simple_pointer(NULL);
23459 }
23460
23461 static inline size_t
vn_sizeof_VkDeviceQueueInfo2_self(const VkDeviceQueueInfo2 * val)23462 vn_sizeof_VkDeviceQueueInfo2_self(const VkDeviceQueueInfo2 *val)
23463 {
23464 size_t size = 0;
23465 /* skip val->{sType,pNext} */
23466 size += vn_sizeof_VkFlags(&val->flags);
23467 size += vn_sizeof_uint32_t(&val->queueFamilyIndex);
23468 size += vn_sizeof_uint32_t(&val->queueIndex);
23469 return size;
23470 }
23471
23472 static inline size_t
vn_sizeof_VkDeviceQueueInfo2(const VkDeviceQueueInfo2 * val)23473 vn_sizeof_VkDeviceQueueInfo2(const VkDeviceQueueInfo2 *val)
23474 {
23475 size_t size = 0;
23476
23477 size += vn_sizeof_VkStructureType(&val->sType);
23478 size += vn_sizeof_VkDeviceQueueInfo2_pnext(val->pNext);
23479 size += vn_sizeof_VkDeviceQueueInfo2_self(val);
23480
23481 return size;
23482 }
23483
23484 static inline void
vn_encode_VkDeviceQueueInfo2_pnext(struct vn_cs_encoder * enc,const void * val)23485 vn_encode_VkDeviceQueueInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
23486 {
23487 const VkBaseInStructure *pnext = val;
23488
23489 while (pnext) {
23490 switch ((int32_t)pnext->sType) {
23491 case VK_STRUCTURE_TYPE_DEVICE_QUEUE_TIMELINE_INFO_MESA:
23492 vn_encode_simple_pointer(enc, pnext);
23493 vn_encode_VkStructureType(enc, &pnext->sType);
23494 vn_encode_VkDeviceQueueInfo2_pnext(enc, pnext->pNext);
23495 vn_encode_VkDeviceQueueTimelineInfoMESA_self(enc, (const VkDeviceQueueTimelineInfoMESA *)pnext);
23496 return;
23497 default:
23498 /* ignore unknown/unsupported struct */
23499 break;
23500 }
23501 pnext = pnext->pNext;
23502 }
23503
23504 vn_encode_simple_pointer(enc, NULL);
23505 }
23506
23507 static inline void
vn_encode_VkDeviceQueueInfo2_self(struct vn_cs_encoder * enc,const VkDeviceQueueInfo2 * val)23508 vn_encode_VkDeviceQueueInfo2_self(struct vn_cs_encoder *enc, const VkDeviceQueueInfo2 *val)
23509 {
23510 /* skip val->{sType,pNext} */
23511 vn_encode_VkFlags(enc, &val->flags);
23512 vn_encode_uint32_t(enc, &val->queueFamilyIndex);
23513 vn_encode_uint32_t(enc, &val->queueIndex);
23514 }
23515
23516 static inline void
vn_encode_VkDeviceQueueInfo2(struct vn_cs_encoder * enc,const VkDeviceQueueInfo2 * val)23517 vn_encode_VkDeviceQueueInfo2(struct vn_cs_encoder *enc, const VkDeviceQueueInfo2 *val)
23518 {
23519 assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2);
23520 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 });
23521 vn_encode_VkDeviceQueueInfo2_pnext(enc, val->pNext);
23522 vn_encode_VkDeviceQueueInfo2_self(enc, val);
23523 }
23524
23525 /* struct VkCalibratedTimestampInfoEXT chain */
23526
23527 static inline size_t
vn_sizeof_VkCalibratedTimestampInfoEXT_pnext(const void * val)23528 vn_sizeof_VkCalibratedTimestampInfoEXT_pnext(const void *val)
23529 {
23530 /* no known/supported struct */
23531 return vn_sizeof_simple_pointer(NULL);
23532 }
23533
23534 static inline size_t
vn_sizeof_VkCalibratedTimestampInfoEXT_self(const VkCalibratedTimestampInfoEXT * val)23535 vn_sizeof_VkCalibratedTimestampInfoEXT_self(const VkCalibratedTimestampInfoEXT *val)
23536 {
23537 size_t size = 0;
23538 /* skip val->{sType,pNext} */
23539 size += vn_sizeof_VkTimeDomainEXT(&val->timeDomain);
23540 return size;
23541 }
23542
23543 static inline size_t
vn_sizeof_VkCalibratedTimestampInfoEXT(const VkCalibratedTimestampInfoEXT * val)23544 vn_sizeof_VkCalibratedTimestampInfoEXT(const VkCalibratedTimestampInfoEXT *val)
23545 {
23546 size_t size = 0;
23547
23548 size += vn_sizeof_VkStructureType(&val->sType);
23549 size += vn_sizeof_VkCalibratedTimestampInfoEXT_pnext(val->pNext);
23550 size += vn_sizeof_VkCalibratedTimestampInfoEXT_self(val);
23551
23552 return size;
23553 }
23554
23555 static inline void
vn_encode_VkCalibratedTimestampInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)23556 vn_encode_VkCalibratedTimestampInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
23557 {
23558 /* no known/supported struct */
23559 vn_encode_simple_pointer(enc, NULL);
23560 }
23561
23562 static inline void
vn_encode_VkCalibratedTimestampInfoEXT_self(struct vn_cs_encoder * enc,const VkCalibratedTimestampInfoEXT * val)23563 vn_encode_VkCalibratedTimestampInfoEXT_self(struct vn_cs_encoder *enc, const VkCalibratedTimestampInfoEXT *val)
23564 {
23565 /* skip val->{sType,pNext} */
23566 vn_encode_VkTimeDomainEXT(enc, &val->timeDomain);
23567 }
23568
23569 static inline void
vn_encode_VkCalibratedTimestampInfoEXT(struct vn_cs_encoder * enc,const VkCalibratedTimestampInfoEXT * val)23570 vn_encode_VkCalibratedTimestampInfoEXT(struct vn_cs_encoder *enc, const VkCalibratedTimestampInfoEXT *val)
23571 {
23572 assert(val->sType == VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT);
23573 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT });
23574 vn_encode_VkCalibratedTimestampInfoEXT_pnext(enc, val->pNext);
23575 vn_encode_VkCalibratedTimestampInfoEXT_self(enc, val);
23576 }
23577
23578 /* struct VkPhysicalDeviceToolProperties chain */
23579
23580 static inline size_t
vn_sizeof_VkPhysicalDeviceToolProperties_pnext(const void * val)23581 vn_sizeof_VkPhysicalDeviceToolProperties_pnext(const void *val)
23582 {
23583 /* no known/supported struct */
23584 return vn_sizeof_simple_pointer(NULL);
23585 }
23586
23587 static inline size_t
vn_sizeof_VkPhysicalDeviceToolProperties_self(const VkPhysicalDeviceToolProperties * val)23588 vn_sizeof_VkPhysicalDeviceToolProperties_self(const VkPhysicalDeviceToolProperties *val)
23589 {
23590 size_t size = 0;
23591 /* skip val->{sType,pNext} */
23592 size += vn_sizeof_array_size(VK_MAX_EXTENSION_NAME_SIZE);
23593 size += vn_sizeof_char_array(val->name, VK_MAX_EXTENSION_NAME_SIZE);
23594 size += vn_sizeof_array_size(VK_MAX_EXTENSION_NAME_SIZE);
23595 size += vn_sizeof_char_array(val->version, VK_MAX_EXTENSION_NAME_SIZE);
23596 size += vn_sizeof_VkFlags(&val->purposes);
23597 size += vn_sizeof_array_size(VK_MAX_DESCRIPTION_SIZE);
23598 size += vn_sizeof_char_array(val->description, VK_MAX_DESCRIPTION_SIZE);
23599 size += vn_sizeof_array_size(VK_MAX_EXTENSION_NAME_SIZE);
23600 size += vn_sizeof_char_array(val->layer, VK_MAX_EXTENSION_NAME_SIZE);
23601 return size;
23602 }
23603
23604 static inline size_t
vn_sizeof_VkPhysicalDeviceToolProperties(const VkPhysicalDeviceToolProperties * val)23605 vn_sizeof_VkPhysicalDeviceToolProperties(const VkPhysicalDeviceToolProperties *val)
23606 {
23607 size_t size = 0;
23608
23609 size += vn_sizeof_VkStructureType(&val->sType);
23610 size += vn_sizeof_VkPhysicalDeviceToolProperties_pnext(val->pNext);
23611 size += vn_sizeof_VkPhysicalDeviceToolProperties_self(val);
23612
23613 return size;
23614 }
23615
23616 static inline void
vn_decode_VkPhysicalDeviceToolProperties_pnext(struct vn_cs_decoder * dec,const void * val)23617 vn_decode_VkPhysicalDeviceToolProperties_pnext(struct vn_cs_decoder *dec, const void *val)
23618 {
23619 /* no known/supported struct */
23620 if (vn_decode_simple_pointer(dec))
23621 assert(false);
23622 }
23623
23624 static inline void
vn_decode_VkPhysicalDeviceToolProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceToolProperties * val)23625 vn_decode_VkPhysicalDeviceToolProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceToolProperties *val)
23626 {
23627 /* skip val->{sType,pNext} */
23628 {
23629 const size_t array_size = vn_decode_array_size(dec, VK_MAX_EXTENSION_NAME_SIZE);
23630 vn_decode_char_array(dec, val->name, array_size);
23631 }
23632 {
23633 const size_t array_size = vn_decode_array_size(dec, VK_MAX_EXTENSION_NAME_SIZE);
23634 vn_decode_char_array(dec, val->version, array_size);
23635 }
23636 vn_decode_VkFlags(dec, &val->purposes);
23637 {
23638 const size_t array_size = vn_decode_array_size(dec, VK_MAX_DESCRIPTION_SIZE);
23639 vn_decode_char_array(dec, val->description, array_size);
23640 }
23641 {
23642 const size_t array_size = vn_decode_array_size(dec, VK_MAX_EXTENSION_NAME_SIZE);
23643 vn_decode_char_array(dec, val->layer, array_size);
23644 }
23645 }
23646
23647 static inline void
vn_decode_VkPhysicalDeviceToolProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceToolProperties * val)23648 vn_decode_VkPhysicalDeviceToolProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceToolProperties *val)
23649 {
23650 VkStructureType stype;
23651 vn_decode_VkStructureType(dec, &stype);
23652 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES);
23653
23654 assert(val->sType == stype);
23655 vn_decode_VkPhysicalDeviceToolProperties_pnext(dec, val->pNext);
23656 vn_decode_VkPhysicalDeviceToolProperties_self(dec, val);
23657 }
23658
23659 static inline size_t
vn_sizeof_VkPhysicalDeviceToolProperties_pnext_partial(const void * val)23660 vn_sizeof_VkPhysicalDeviceToolProperties_pnext_partial(const void *val)
23661 {
23662 /* no known/supported struct */
23663 return vn_sizeof_simple_pointer(NULL);
23664 }
23665
23666 static inline size_t
vn_sizeof_VkPhysicalDeviceToolProperties_self_partial(const VkPhysicalDeviceToolProperties * val)23667 vn_sizeof_VkPhysicalDeviceToolProperties_self_partial(const VkPhysicalDeviceToolProperties *val)
23668 {
23669 size_t size = 0;
23670 /* skip val->{sType,pNext} */
23671 /* skip val->name */
23672 /* skip val->version */
23673 /* skip val->purposes */
23674 /* skip val->description */
23675 /* skip val->layer */
23676 return size;
23677 }
23678
23679 static inline size_t
vn_sizeof_VkPhysicalDeviceToolProperties_partial(const VkPhysicalDeviceToolProperties * val)23680 vn_sizeof_VkPhysicalDeviceToolProperties_partial(const VkPhysicalDeviceToolProperties *val)
23681 {
23682 size_t size = 0;
23683
23684 size += vn_sizeof_VkStructureType(&val->sType);
23685 size += vn_sizeof_VkPhysicalDeviceToolProperties_pnext_partial(val->pNext);
23686 size += vn_sizeof_VkPhysicalDeviceToolProperties_self_partial(val);
23687
23688 return size;
23689 }
23690
23691 static inline void
vn_encode_VkPhysicalDeviceToolProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)23692 vn_encode_VkPhysicalDeviceToolProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
23693 {
23694 /* no known/supported struct */
23695 vn_encode_simple_pointer(enc, NULL);
23696 }
23697
23698 static inline void
vn_encode_VkPhysicalDeviceToolProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceToolProperties * val)23699 vn_encode_VkPhysicalDeviceToolProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceToolProperties *val)
23700 {
23701 /* skip val->{sType,pNext} */
23702 /* skip val->name */
23703 /* skip val->version */
23704 /* skip val->purposes */
23705 /* skip val->description */
23706 /* skip val->layer */
23707 }
23708
23709 static inline void
vn_encode_VkPhysicalDeviceToolProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceToolProperties * val)23710 vn_encode_VkPhysicalDeviceToolProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceToolProperties *val)
23711 {
23712 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES);
23713 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES });
23714 vn_encode_VkPhysicalDeviceToolProperties_pnext_partial(enc, val->pNext);
23715 vn_encode_VkPhysicalDeviceToolProperties_self_partial(enc, val);
23716 }
23717
23718 /* struct VkPhysicalDeviceFragmentShadingRateKHR chain */
23719
23720 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShadingRateKHR_pnext(const void * val)23721 vn_sizeof_VkPhysicalDeviceFragmentShadingRateKHR_pnext(const void *val)
23722 {
23723 /* no known/supported struct */
23724 return vn_sizeof_simple_pointer(NULL);
23725 }
23726
23727 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShadingRateKHR_self(const VkPhysicalDeviceFragmentShadingRateKHR * val)23728 vn_sizeof_VkPhysicalDeviceFragmentShadingRateKHR_self(const VkPhysicalDeviceFragmentShadingRateKHR *val)
23729 {
23730 size_t size = 0;
23731 /* skip val->{sType,pNext} */
23732 size += vn_sizeof_VkFlags(&val->sampleCounts);
23733 size += vn_sizeof_VkExtent2D(&val->fragmentSize);
23734 return size;
23735 }
23736
23737 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShadingRateKHR(const VkPhysicalDeviceFragmentShadingRateKHR * val)23738 vn_sizeof_VkPhysicalDeviceFragmentShadingRateKHR(const VkPhysicalDeviceFragmentShadingRateKHR *val)
23739 {
23740 size_t size = 0;
23741
23742 size += vn_sizeof_VkStructureType(&val->sType);
23743 size += vn_sizeof_VkPhysicalDeviceFragmentShadingRateKHR_pnext(val->pNext);
23744 size += vn_sizeof_VkPhysicalDeviceFragmentShadingRateKHR_self(val);
23745
23746 return size;
23747 }
23748
23749 static inline void
vn_decode_VkPhysicalDeviceFragmentShadingRateKHR_pnext(struct vn_cs_decoder * dec,const void * val)23750 vn_decode_VkPhysicalDeviceFragmentShadingRateKHR_pnext(struct vn_cs_decoder *dec, const void *val)
23751 {
23752 /* no known/supported struct */
23753 if (vn_decode_simple_pointer(dec))
23754 assert(false);
23755 }
23756
23757 static inline void
vn_decode_VkPhysicalDeviceFragmentShadingRateKHR_self(struct vn_cs_decoder * dec,VkPhysicalDeviceFragmentShadingRateKHR * val)23758 vn_decode_VkPhysicalDeviceFragmentShadingRateKHR_self(struct vn_cs_decoder *dec, VkPhysicalDeviceFragmentShadingRateKHR *val)
23759 {
23760 /* skip val->{sType,pNext} */
23761 vn_decode_VkFlags(dec, &val->sampleCounts);
23762 vn_decode_VkExtent2D(dec, &val->fragmentSize);
23763 }
23764
23765 static inline void
vn_decode_VkPhysicalDeviceFragmentShadingRateKHR(struct vn_cs_decoder * dec,VkPhysicalDeviceFragmentShadingRateKHR * val)23766 vn_decode_VkPhysicalDeviceFragmentShadingRateKHR(struct vn_cs_decoder *dec, VkPhysicalDeviceFragmentShadingRateKHR *val)
23767 {
23768 VkStructureType stype;
23769 vn_decode_VkStructureType(dec, &stype);
23770 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR);
23771
23772 assert(val->sType == stype);
23773 vn_decode_VkPhysicalDeviceFragmentShadingRateKHR_pnext(dec, val->pNext);
23774 vn_decode_VkPhysicalDeviceFragmentShadingRateKHR_self(dec, val);
23775 }
23776
23777 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShadingRateKHR_pnext_partial(const void * val)23778 vn_sizeof_VkPhysicalDeviceFragmentShadingRateKHR_pnext_partial(const void *val)
23779 {
23780 /* no known/supported struct */
23781 return vn_sizeof_simple_pointer(NULL);
23782 }
23783
23784 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShadingRateKHR_self_partial(const VkPhysicalDeviceFragmentShadingRateKHR * val)23785 vn_sizeof_VkPhysicalDeviceFragmentShadingRateKHR_self_partial(const VkPhysicalDeviceFragmentShadingRateKHR *val)
23786 {
23787 size_t size = 0;
23788 /* skip val->{sType,pNext} */
23789 /* skip val->sampleCounts */
23790 size += vn_sizeof_VkExtent2D_partial(&val->fragmentSize);
23791 return size;
23792 }
23793
23794 static inline size_t
vn_sizeof_VkPhysicalDeviceFragmentShadingRateKHR_partial(const VkPhysicalDeviceFragmentShadingRateKHR * val)23795 vn_sizeof_VkPhysicalDeviceFragmentShadingRateKHR_partial(const VkPhysicalDeviceFragmentShadingRateKHR *val)
23796 {
23797 size_t size = 0;
23798
23799 size += vn_sizeof_VkStructureType(&val->sType);
23800 size += vn_sizeof_VkPhysicalDeviceFragmentShadingRateKHR_pnext_partial(val->pNext);
23801 size += vn_sizeof_VkPhysicalDeviceFragmentShadingRateKHR_self_partial(val);
23802
23803 return size;
23804 }
23805
23806 static inline void
vn_encode_VkPhysicalDeviceFragmentShadingRateKHR_pnext_partial(struct vn_cs_encoder * enc,const void * val)23807 vn_encode_VkPhysicalDeviceFragmentShadingRateKHR_pnext_partial(struct vn_cs_encoder *enc, const void *val)
23808 {
23809 /* no known/supported struct */
23810 vn_encode_simple_pointer(enc, NULL);
23811 }
23812
23813 static inline void
vn_encode_VkPhysicalDeviceFragmentShadingRateKHR_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFragmentShadingRateKHR * val)23814 vn_encode_VkPhysicalDeviceFragmentShadingRateKHR_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFragmentShadingRateKHR *val)
23815 {
23816 /* skip val->{sType,pNext} */
23817 /* skip val->sampleCounts */
23818 vn_encode_VkExtent2D_partial(enc, &val->fragmentSize);
23819 }
23820
23821 static inline void
vn_encode_VkPhysicalDeviceFragmentShadingRateKHR_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFragmentShadingRateKHR * val)23822 vn_encode_VkPhysicalDeviceFragmentShadingRateKHR_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFragmentShadingRateKHR *val)
23823 {
23824 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR);
23825 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR });
23826 vn_encode_VkPhysicalDeviceFragmentShadingRateKHR_pnext_partial(enc, val->pNext);
23827 vn_encode_VkPhysicalDeviceFragmentShadingRateKHR_self_partial(enc, val);
23828 }
23829
vn_sizeof_vkEnumeratePhysicalDevices(VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)23830 static inline size_t vn_sizeof_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
23831 {
23832 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT;
23833 const VkFlags cmd_flags = 0;
23834 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
23835
23836 cmd_size += vn_sizeof_VkInstance(&instance);
23837 cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceCount);
23838 if (pPhysicalDeviceCount)
23839 cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceCount);
23840 if (pPhysicalDevices) {
23841 cmd_size += vn_sizeof_array_size((pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0));
23842 for (uint32_t i = 0; i < (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0); i++)
23843 cmd_size += vn_sizeof_VkPhysicalDevice(&pPhysicalDevices[i]);
23844 } else {
23845 cmd_size += vn_sizeof_array_size(0);
23846 }
23847
23848 return cmd_size;
23849 }
23850
vn_encode_vkEnumeratePhysicalDevices(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)23851 static inline void vn_encode_vkEnumeratePhysicalDevices(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
23852 {
23853 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT;
23854
23855 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
23856 vn_encode_VkFlags(enc, &cmd_flags);
23857
23858 vn_encode_VkInstance(enc, &instance);
23859 if (vn_encode_simple_pointer(enc, pPhysicalDeviceCount))
23860 vn_encode_uint32_t(enc, pPhysicalDeviceCount);
23861 if (pPhysicalDevices) {
23862 vn_encode_array_size(enc, (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0));
23863 for (uint32_t i = 0; i < (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0); i++)
23864 vn_encode_VkPhysicalDevice(enc, &pPhysicalDevices[i]);
23865 } else {
23866 vn_encode_array_size(enc, 0);
23867 }
23868 }
23869
vn_sizeof_vkEnumeratePhysicalDevices_reply(VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)23870 static inline size_t vn_sizeof_vkEnumeratePhysicalDevices_reply(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
23871 {
23872 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT;
23873 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
23874
23875 VkResult ret;
23876 cmd_size += vn_sizeof_VkResult(&ret);
23877 /* skip instance */
23878 cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceCount);
23879 if (pPhysicalDeviceCount)
23880 cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceCount);
23881 if (pPhysicalDevices) {
23882 cmd_size += vn_sizeof_array_size((pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0));
23883 for (uint32_t i = 0; i < (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0); i++)
23884 cmd_size += vn_sizeof_VkPhysicalDevice(&pPhysicalDevices[i]);
23885 } else {
23886 cmd_size += vn_sizeof_array_size(0);
23887 }
23888
23889 return cmd_size;
23890 }
23891
vn_decode_vkEnumeratePhysicalDevices_reply(struct vn_cs_decoder * dec,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)23892 static inline VkResult vn_decode_vkEnumeratePhysicalDevices_reply(struct vn_cs_decoder *dec, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
23893 {
23894 VkCommandTypeEXT command_type;
23895 vn_decode_VkCommandTypeEXT(dec, &command_type);
23896 assert(command_type == VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT);
23897
23898 VkResult ret;
23899 vn_decode_VkResult(dec, &ret);
23900 /* skip instance */
23901 if (vn_decode_simple_pointer(dec)) {
23902 vn_decode_uint32_t(dec, pPhysicalDeviceCount);
23903 } else {
23904 pPhysicalDeviceCount = NULL;
23905 }
23906 if (vn_peek_array_size(dec)) {
23907 const uint32_t iter_count = vn_decode_array_size(dec, (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0));
23908 for (uint32_t i = 0; i < iter_count; i++)
23909 vn_decode_VkPhysicalDevice(dec, &pPhysicalDevices[i]);
23910 } else {
23911 vn_decode_array_size_unchecked(dec);
23912 pPhysicalDevices = NULL;
23913 }
23914
23915 return ret;
23916 }
23917
vn_sizeof_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)23918 static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
23919 {
23920 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT;
23921 const VkFlags cmd_flags = 0;
23922 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
23923
23924 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
23925 cmd_size += vn_sizeof_simple_pointer(pProperties);
23926 if (pProperties)
23927 cmd_size += vn_sizeof_VkPhysicalDeviceProperties_partial(pProperties);
23928
23929 return cmd_size;
23930 }
23931
vn_encode_vkGetPhysicalDeviceProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)23932 static inline void vn_encode_vkGetPhysicalDeviceProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
23933 {
23934 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT;
23935
23936 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
23937 vn_encode_VkFlags(enc, &cmd_flags);
23938
23939 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
23940 if (vn_encode_simple_pointer(enc, pProperties))
23941 vn_encode_VkPhysicalDeviceProperties_partial(enc, pProperties);
23942 }
23943
vn_sizeof_vkGetPhysicalDeviceProperties_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)23944 static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
23945 {
23946 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT;
23947 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
23948
23949 /* skip physicalDevice */
23950 cmd_size += vn_sizeof_simple_pointer(pProperties);
23951 if (pProperties)
23952 cmd_size += vn_sizeof_VkPhysicalDeviceProperties(pProperties);
23953
23954 return cmd_size;
23955 }
23956
vn_decode_vkGetPhysicalDeviceProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)23957 static inline void vn_decode_vkGetPhysicalDeviceProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
23958 {
23959 VkCommandTypeEXT command_type;
23960 vn_decode_VkCommandTypeEXT(dec, &command_type);
23961 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT);
23962
23963 /* skip physicalDevice */
23964 if (vn_decode_simple_pointer(dec)) {
23965 vn_decode_VkPhysicalDeviceProperties(dec, pProperties);
23966 } else {
23967 pProperties = NULL;
23968 }
23969 }
23970
vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)23971 static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
23972 {
23973 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT;
23974 const VkFlags cmd_flags = 0;
23975 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
23976
23977 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
23978 cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
23979 if (pQueueFamilyPropertyCount)
23980 cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
23981 if (pQueueFamilyProperties) {
23982 cmd_size += vn_sizeof_array_size((pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
23983 for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
23984 cmd_size += vn_sizeof_VkQueueFamilyProperties_partial(&pQueueFamilyProperties[i]);
23985 } else {
23986 cmd_size += vn_sizeof_array_size(0);
23987 }
23988
23989 return cmd_size;
23990 }
23991
vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)23992 static inline void vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
23993 {
23994 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT;
23995
23996 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
23997 vn_encode_VkFlags(enc, &cmd_flags);
23998
23999 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
24000 if (vn_encode_simple_pointer(enc, pQueueFamilyPropertyCount))
24001 vn_encode_uint32_t(enc, pQueueFamilyPropertyCount);
24002 if (pQueueFamilyProperties) {
24003 vn_encode_array_size(enc, (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
24004 for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
24005 vn_encode_VkQueueFamilyProperties_partial(enc, &pQueueFamilyProperties[i]);
24006 } else {
24007 vn_encode_array_size(enc, 0);
24008 }
24009 }
24010
vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)24011 static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
24012 {
24013 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT;
24014 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
24015
24016 /* skip physicalDevice */
24017 cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
24018 if (pQueueFamilyPropertyCount)
24019 cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
24020 if (pQueueFamilyProperties) {
24021 cmd_size += vn_sizeof_array_size((pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
24022 for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
24023 cmd_size += vn_sizeof_VkQueueFamilyProperties(&pQueueFamilyProperties[i]);
24024 } else {
24025 cmd_size += vn_sizeof_array_size(0);
24026 }
24027
24028 return cmd_size;
24029 }
24030
vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)24031 static inline void vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
24032 {
24033 VkCommandTypeEXT command_type;
24034 vn_decode_VkCommandTypeEXT(dec, &command_type);
24035 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT);
24036
24037 /* skip physicalDevice */
24038 if (vn_decode_simple_pointer(dec)) {
24039 vn_decode_uint32_t(dec, pQueueFamilyPropertyCount);
24040 } else {
24041 pQueueFamilyPropertyCount = NULL;
24042 }
24043 if (vn_peek_array_size(dec)) {
24044 const uint32_t iter_count = vn_decode_array_size(dec, (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
24045 for (uint32_t i = 0; i < iter_count; i++)
24046 vn_decode_VkQueueFamilyProperties(dec, &pQueueFamilyProperties[i]);
24047 } else {
24048 vn_decode_array_size_unchecked(dec);
24049 pQueueFamilyProperties = NULL;
24050 }
24051 }
24052
vn_sizeof_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)24053 static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
24054 {
24055 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT;
24056 const VkFlags cmd_flags = 0;
24057 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
24058
24059 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
24060 cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
24061 if (pMemoryProperties)
24062 cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(pMemoryProperties);
24063
24064 return cmd_size;
24065 }
24066
vn_encode_vkGetPhysicalDeviceMemoryProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)24067 static inline void vn_encode_vkGetPhysicalDeviceMemoryProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
24068 {
24069 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT;
24070
24071 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
24072 vn_encode_VkFlags(enc, &cmd_flags);
24073
24074 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
24075 if (vn_encode_simple_pointer(enc, pMemoryProperties))
24076 vn_encode_VkPhysicalDeviceMemoryProperties_partial(enc, pMemoryProperties);
24077 }
24078
vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)24079 static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
24080 {
24081 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT;
24082 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
24083
24084 /* skip physicalDevice */
24085 cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
24086 if (pMemoryProperties)
24087 cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties(pMemoryProperties);
24088
24089 return cmd_size;
24090 }
24091
vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)24092 static inline void vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
24093 {
24094 VkCommandTypeEXT command_type;
24095 vn_decode_VkCommandTypeEXT(dec, &command_type);
24096 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT);
24097
24098 /* skip physicalDevice */
24099 if (vn_decode_simple_pointer(dec)) {
24100 vn_decode_VkPhysicalDeviceMemoryProperties(dec, pMemoryProperties);
24101 } else {
24102 pMemoryProperties = NULL;
24103 }
24104 }
24105
vn_sizeof_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)24106 static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
24107 {
24108 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT;
24109 const VkFlags cmd_flags = 0;
24110 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
24111
24112 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
24113 cmd_size += vn_sizeof_simple_pointer(pFeatures);
24114 if (pFeatures)
24115 cmd_size += vn_sizeof_VkPhysicalDeviceFeatures_partial(pFeatures);
24116
24117 return cmd_size;
24118 }
24119
vn_encode_vkGetPhysicalDeviceFeatures(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)24120 static inline void vn_encode_vkGetPhysicalDeviceFeatures(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
24121 {
24122 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT;
24123
24124 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
24125 vn_encode_VkFlags(enc, &cmd_flags);
24126
24127 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
24128 if (vn_encode_simple_pointer(enc, pFeatures))
24129 vn_encode_VkPhysicalDeviceFeatures_partial(enc, pFeatures);
24130 }
24131
vn_sizeof_vkGetPhysicalDeviceFeatures_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)24132 static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
24133 {
24134 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT;
24135 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
24136
24137 /* skip physicalDevice */
24138 cmd_size += vn_sizeof_simple_pointer(pFeatures);
24139 if (pFeatures)
24140 cmd_size += vn_sizeof_VkPhysicalDeviceFeatures(pFeatures);
24141
24142 return cmd_size;
24143 }
24144
vn_decode_vkGetPhysicalDeviceFeatures_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)24145 static inline void vn_decode_vkGetPhysicalDeviceFeatures_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
24146 {
24147 VkCommandTypeEXT command_type;
24148 vn_decode_VkCommandTypeEXT(dec, &command_type);
24149 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT);
24150
24151 /* skip physicalDevice */
24152 if (vn_decode_simple_pointer(dec)) {
24153 vn_decode_VkPhysicalDeviceFeatures(dec, pFeatures);
24154 } else {
24155 pFeatures = NULL;
24156 }
24157 }
24158
vn_sizeof_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)24159 static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
24160 {
24161 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT;
24162 const VkFlags cmd_flags = 0;
24163 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
24164
24165 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
24166 cmd_size += vn_sizeof_VkFormat(&format);
24167 cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
24168 if (pFormatProperties)
24169 cmd_size += vn_sizeof_VkFormatProperties_partial(pFormatProperties);
24170
24171 return cmd_size;
24172 }
24173
vn_encode_vkGetPhysicalDeviceFormatProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)24174 static inline void vn_encode_vkGetPhysicalDeviceFormatProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
24175 {
24176 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT;
24177
24178 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
24179 vn_encode_VkFlags(enc, &cmd_flags);
24180
24181 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
24182 vn_encode_VkFormat(enc, &format);
24183 if (vn_encode_simple_pointer(enc, pFormatProperties))
24184 vn_encode_VkFormatProperties_partial(enc, pFormatProperties);
24185 }
24186
vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)24187 static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
24188 {
24189 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT;
24190 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
24191
24192 /* skip physicalDevice */
24193 /* skip format */
24194 cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
24195 if (pFormatProperties)
24196 cmd_size += vn_sizeof_VkFormatProperties(pFormatProperties);
24197
24198 return cmd_size;
24199 }
24200
vn_decode_vkGetPhysicalDeviceFormatProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)24201 static inline void vn_decode_vkGetPhysicalDeviceFormatProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
24202 {
24203 VkCommandTypeEXT command_type;
24204 vn_decode_VkCommandTypeEXT(dec, &command_type);
24205 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT);
24206
24207 /* skip physicalDevice */
24208 /* skip format */
24209 if (vn_decode_simple_pointer(dec)) {
24210 vn_decode_VkFormatProperties(dec, pFormatProperties);
24211 } else {
24212 pFormatProperties = NULL;
24213 }
24214 }
24215
vn_sizeof_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)24216 static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
24217 {
24218 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT;
24219 const VkFlags cmd_flags = 0;
24220 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
24221
24222 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
24223 cmd_size += vn_sizeof_VkFormat(&format);
24224 cmd_size += vn_sizeof_VkImageType(&type);
24225 cmd_size += vn_sizeof_VkImageTiling(&tiling);
24226 cmd_size += vn_sizeof_VkFlags(&usage);
24227 cmd_size += vn_sizeof_VkFlags(&flags);
24228 cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
24229 if (pImageFormatProperties)
24230 cmd_size += vn_sizeof_VkImageFormatProperties_partial(pImageFormatProperties);
24231
24232 return cmd_size;
24233 }
24234
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)24235 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)
24236 {
24237 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT;
24238
24239 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
24240 vn_encode_VkFlags(enc, &cmd_flags);
24241
24242 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
24243 vn_encode_VkFormat(enc, &format);
24244 vn_encode_VkImageType(enc, &type);
24245 vn_encode_VkImageTiling(enc, &tiling);
24246 vn_encode_VkFlags(enc, &usage);
24247 vn_encode_VkFlags(enc, &flags);
24248 if (vn_encode_simple_pointer(enc, pImageFormatProperties))
24249 vn_encode_VkImageFormatProperties_partial(enc, pImageFormatProperties);
24250 }
24251
vn_sizeof_vkGetPhysicalDeviceImageFormatProperties_reply(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)24252 static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
24253 {
24254 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT;
24255 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
24256
24257 VkResult ret;
24258 cmd_size += vn_sizeof_VkResult(&ret);
24259 /* skip physicalDevice */
24260 /* skip format */
24261 /* skip type */
24262 /* skip tiling */
24263 /* skip usage */
24264 /* skip flags */
24265 cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
24266 if (pImageFormatProperties)
24267 cmd_size += vn_sizeof_VkImageFormatProperties(pImageFormatProperties);
24268
24269 return cmd_size;
24270 }
24271
vn_decode_vkGetPhysicalDeviceImageFormatProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)24272 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)
24273 {
24274 VkCommandTypeEXT command_type;
24275 vn_decode_VkCommandTypeEXT(dec, &command_type);
24276 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT);
24277
24278 VkResult ret;
24279 vn_decode_VkResult(dec, &ret);
24280 /* skip physicalDevice */
24281 /* skip format */
24282 /* skip type */
24283 /* skip tiling */
24284 /* skip usage */
24285 /* skip flags */
24286 if (vn_decode_simple_pointer(dec)) {
24287 vn_decode_VkImageFormatProperties(dec, pImageFormatProperties);
24288 } else {
24289 pImageFormatProperties = NULL;
24290 }
24291
24292 return ret;
24293 }
24294
vn_sizeof_vkCreateDevice(VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)24295 static inline size_t vn_sizeof_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
24296 {
24297 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT;
24298 const VkFlags cmd_flags = 0;
24299 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
24300
24301 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
24302 cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
24303 if (pCreateInfo)
24304 cmd_size += vn_sizeof_VkDeviceCreateInfo(pCreateInfo);
24305 cmd_size += vn_sizeof_simple_pointer(pAllocator);
24306 if (pAllocator)
24307 assert(false);
24308 cmd_size += vn_sizeof_simple_pointer(pDevice);
24309 if (pDevice)
24310 cmd_size += vn_sizeof_VkDevice(pDevice);
24311
24312 return cmd_size;
24313 }
24314
vn_encode_vkCreateDevice(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)24315 static inline void vn_encode_vkCreateDevice(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
24316 {
24317 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT;
24318
24319 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
24320 vn_encode_VkFlags(enc, &cmd_flags);
24321
24322 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
24323 if (vn_encode_simple_pointer(enc, pCreateInfo))
24324 vn_encode_VkDeviceCreateInfo(enc, pCreateInfo);
24325 if (vn_encode_simple_pointer(enc, pAllocator))
24326 assert(false);
24327 if (vn_encode_simple_pointer(enc, pDevice))
24328 vn_encode_VkDevice(enc, pDevice);
24329 }
24330
vn_sizeof_vkCreateDevice_reply(VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)24331 static inline size_t vn_sizeof_vkCreateDevice_reply(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
24332 {
24333 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT;
24334 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
24335
24336 VkResult ret;
24337 cmd_size += vn_sizeof_VkResult(&ret);
24338 /* skip physicalDevice */
24339 /* skip pCreateInfo */
24340 /* skip pAllocator */
24341 cmd_size += vn_sizeof_simple_pointer(pDevice);
24342 if (pDevice)
24343 cmd_size += vn_sizeof_VkDevice(pDevice);
24344
24345 return cmd_size;
24346 }
24347
vn_decode_vkCreateDevice_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)24348 static inline VkResult vn_decode_vkCreateDevice_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
24349 {
24350 VkCommandTypeEXT command_type;
24351 vn_decode_VkCommandTypeEXT(dec, &command_type);
24352 assert(command_type == VK_COMMAND_TYPE_vkCreateDevice_EXT);
24353
24354 VkResult ret;
24355 vn_decode_VkResult(dec, &ret);
24356 /* skip physicalDevice */
24357 /* skip pCreateInfo */
24358 /* skip pAllocator */
24359 if (vn_decode_simple_pointer(dec)) {
24360 vn_decode_VkDevice(dec, pDevice);
24361 } else {
24362 pDevice = NULL;
24363 }
24364
24365 return ret;
24366 }
24367
vn_sizeof_vkDestroyDevice(VkDevice device,const VkAllocationCallbacks * pAllocator)24368 static inline size_t vn_sizeof_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
24369 {
24370 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT;
24371 const VkFlags cmd_flags = 0;
24372 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
24373
24374 cmd_size += vn_sizeof_VkDevice(&device);
24375 cmd_size += vn_sizeof_simple_pointer(pAllocator);
24376 if (pAllocator)
24377 assert(false);
24378
24379 return cmd_size;
24380 }
24381
vn_encode_vkDestroyDevice(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkAllocationCallbacks * pAllocator)24382 static inline void vn_encode_vkDestroyDevice(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkAllocationCallbacks* pAllocator)
24383 {
24384 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT;
24385
24386 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
24387 vn_encode_VkFlags(enc, &cmd_flags);
24388
24389 vn_encode_VkDevice(enc, &device);
24390 if (vn_encode_simple_pointer(enc, pAllocator))
24391 assert(false);
24392 }
24393
vn_sizeof_vkDestroyDevice_reply(VkDevice device,const VkAllocationCallbacks * pAllocator)24394 static inline size_t vn_sizeof_vkDestroyDevice_reply(VkDevice device, const VkAllocationCallbacks* pAllocator)
24395 {
24396 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT;
24397 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
24398
24399 /* skip device */
24400 /* skip pAllocator */
24401
24402 return cmd_size;
24403 }
24404
vn_decode_vkDestroyDevice_reply(struct vn_cs_decoder * dec,VkDevice device,const VkAllocationCallbacks * pAllocator)24405 static inline void vn_decode_vkDestroyDevice_reply(struct vn_cs_decoder *dec, VkDevice device, const VkAllocationCallbacks* pAllocator)
24406 {
24407 VkCommandTypeEXT command_type;
24408 vn_decode_VkCommandTypeEXT(dec, &command_type);
24409 assert(command_type == VK_COMMAND_TYPE_vkDestroyDevice_EXT);
24410
24411 /* skip device */
24412 /* skip pAllocator */
24413 }
24414
vn_sizeof_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)24415 static inline size_t vn_sizeof_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
24416 {
24417 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT;
24418 const VkFlags cmd_flags = 0;
24419 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
24420
24421 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
24422 cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
24423 if (pPropertyCount)
24424 cmd_size += vn_sizeof_uint32_t(pPropertyCount);
24425 if (pProperties) {
24426 cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
24427 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
24428 cmd_size += vn_sizeof_VkLayerProperties_partial(&pProperties[i]);
24429 } else {
24430 cmd_size += vn_sizeof_array_size(0);
24431 }
24432
24433 return cmd_size;
24434 }
24435
vn_encode_vkEnumerateDeviceLayerProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)24436 static inline void vn_encode_vkEnumerateDeviceLayerProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
24437 {
24438 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT;
24439
24440 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
24441 vn_encode_VkFlags(enc, &cmd_flags);
24442
24443 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
24444 if (vn_encode_simple_pointer(enc, pPropertyCount))
24445 vn_encode_uint32_t(enc, pPropertyCount);
24446 if (pProperties) {
24447 vn_encode_array_size(enc, (pPropertyCount ? *pPropertyCount : 0));
24448 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
24449 vn_encode_VkLayerProperties_partial(enc, &pProperties[i]);
24450 } else {
24451 vn_encode_array_size(enc, 0);
24452 }
24453 }
24454
vn_sizeof_vkEnumerateDeviceLayerProperties_reply(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)24455 static inline size_t vn_sizeof_vkEnumerateDeviceLayerProperties_reply(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
24456 {
24457 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT;
24458 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
24459
24460 VkResult ret;
24461 cmd_size += vn_sizeof_VkResult(&ret);
24462 /* skip physicalDevice */
24463 cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
24464 if (pPropertyCount)
24465 cmd_size += vn_sizeof_uint32_t(pPropertyCount);
24466 if (pProperties) {
24467 cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
24468 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
24469 cmd_size += vn_sizeof_VkLayerProperties(&pProperties[i]);
24470 } else {
24471 cmd_size += vn_sizeof_array_size(0);
24472 }
24473
24474 return cmd_size;
24475 }
24476
vn_decode_vkEnumerateDeviceLayerProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)24477 static inline VkResult vn_decode_vkEnumerateDeviceLayerProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
24478 {
24479 VkCommandTypeEXT command_type;
24480 vn_decode_VkCommandTypeEXT(dec, &command_type);
24481 assert(command_type == VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT);
24482
24483 VkResult ret;
24484 vn_decode_VkResult(dec, &ret);
24485 /* skip physicalDevice */
24486 if (vn_decode_simple_pointer(dec)) {
24487 vn_decode_uint32_t(dec, pPropertyCount);
24488 } else {
24489 pPropertyCount = NULL;
24490 }
24491 if (vn_peek_array_size(dec)) {
24492 const uint32_t iter_count = vn_decode_array_size(dec, (pPropertyCount ? *pPropertyCount : 0));
24493 for (uint32_t i = 0; i < iter_count; i++)
24494 vn_decode_VkLayerProperties(dec, &pProperties[i]);
24495 } else {
24496 vn_decode_array_size_unchecked(dec);
24497 pProperties = NULL;
24498 }
24499
24500 return ret;
24501 }
24502
vn_sizeof_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)24503 static inline size_t vn_sizeof_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
24504 {
24505 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT;
24506 const VkFlags cmd_flags = 0;
24507 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
24508
24509 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
24510 if (pLayerName) {
24511 const size_t string_size = strlen(pLayerName) + 1;
24512 cmd_size += vn_sizeof_array_size(string_size);
24513 cmd_size += vn_sizeof_char_array(pLayerName, string_size);
24514 } else {
24515 cmd_size += vn_sizeof_array_size(0);
24516 }
24517 cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
24518 if (pPropertyCount)
24519 cmd_size += vn_sizeof_uint32_t(pPropertyCount);
24520 if (pProperties) {
24521 cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
24522 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
24523 cmd_size += vn_sizeof_VkExtensionProperties_partial(&pProperties[i]);
24524 } else {
24525 cmd_size += vn_sizeof_array_size(0);
24526 }
24527
24528 return cmd_size;
24529 }
24530
vn_encode_vkEnumerateDeviceExtensionProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)24531 static inline void vn_encode_vkEnumerateDeviceExtensionProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
24532 {
24533 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT;
24534
24535 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
24536 vn_encode_VkFlags(enc, &cmd_flags);
24537
24538 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
24539 if (pLayerName) {
24540 const size_t string_size = strlen(pLayerName) + 1;
24541 vn_encode_array_size(enc, string_size);
24542 vn_encode_char_array(enc, pLayerName, string_size);
24543 } else {
24544 vn_encode_array_size(enc, 0);
24545 }
24546 if (vn_encode_simple_pointer(enc, pPropertyCount))
24547 vn_encode_uint32_t(enc, pPropertyCount);
24548 if (pProperties) {
24549 vn_encode_array_size(enc, (pPropertyCount ? *pPropertyCount : 0));
24550 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
24551 vn_encode_VkExtensionProperties_partial(enc, &pProperties[i]);
24552 } else {
24553 vn_encode_array_size(enc, 0);
24554 }
24555 }
24556
vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)24557 static inline size_t vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
24558 {
24559 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT;
24560 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
24561
24562 VkResult ret;
24563 cmd_size += vn_sizeof_VkResult(&ret);
24564 /* skip physicalDevice */
24565 /* skip pLayerName */
24566 cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
24567 if (pPropertyCount)
24568 cmd_size += vn_sizeof_uint32_t(pPropertyCount);
24569 if (pProperties) {
24570 cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
24571 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
24572 cmd_size += vn_sizeof_VkExtensionProperties(&pProperties[i]);
24573 } else {
24574 cmd_size += vn_sizeof_array_size(0);
24575 }
24576
24577 return cmd_size;
24578 }
24579
vn_decode_vkEnumerateDeviceExtensionProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)24580 static inline VkResult vn_decode_vkEnumerateDeviceExtensionProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
24581 {
24582 VkCommandTypeEXT command_type;
24583 vn_decode_VkCommandTypeEXT(dec, &command_type);
24584 assert(command_type == VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT);
24585
24586 VkResult ret;
24587 vn_decode_VkResult(dec, &ret);
24588 /* skip physicalDevice */
24589 /* skip pLayerName */
24590 if (vn_decode_simple_pointer(dec)) {
24591 vn_decode_uint32_t(dec, pPropertyCount);
24592 } else {
24593 pPropertyCount = NULL;
24594 }
24595 if (vn_peek_array_size(dec)) {
24596 const uint32_t iter_count = vn_decode_array_size(dec, (pPropertyCount ? *pPropertyCount : 0));
24597 for (uint32_t i = 0; i < iter_count; i++)
24598 vn_decode_VkExtensionProperties(dec, &pProperties[i]);
24599 } else {
24600 vn_decode_array_size_unchecked(dec);
24601 pProperties = NULL;
24602 }
24603
24604 return ret;
24605 }
24606
vn_sizeof_vkGetDeviceQueue(VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)24607 static inline size_t vn_sizeof_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
24608 {
24609 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT;
24610 const VkFlags cmd_flags = 0;
24611 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
24612
24613 cmd_size += vn_sizeof_VkDevice(&device);
24614 cmd_size += vn_sizeof_uint32_t(&queueFamilyIndex);
24615 cmd_size += vn_sizeof_uint32_t(&queueIndex);
24616 cmd_size += vn_sizeof_simple_pointer(pQueue);
24617 if (pQueue)
24618 cmd_size += vn_sizeof_VkQueue(pQueue);
24619
24620 return cmd_size;
24621 }
24622
vn_encode_vkGetDeviceQueue(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)24623 static inline void vn_encode_vkGetDeviceQueue(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
24624 {
24625 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT;
24626
24627 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
24628 vn_encode_VkFlags(enc, &cmd_flags);
24629
24630 vn_encode_VkDevice(enc, &device);
24631 vn_encode_uint32_t(enc, &queueFamilyIndex);
24632 vn_encode_uint32_t(enc, &queueIndex);
24633 if (vn_encode_simple_pointer(enc, pQueue))
24634 vn_encode_VkQueue(enc, pQueue);
24635 }
24636
vn_sizeof_vkGetDeviceQueue_reply(VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)24637 static inline size_t vn_sizeof_vkGetDeviceQueue_reply(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
24638 {
24639 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT;
24640 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
24641
24642 /* skip device */
24643 /* skip queueFamilyIndex */
24644 /* skip queueIndex */
24645 cmd_size += vn_sizeof_simple_pointer(pQueue);
24646 if (pQueue)
24647 cmd_size += vn_sizeof_VkQueue(pQueue);
24648
24649 return cmd_size;
24650 }
24651
vn_decode_vkGetDeviceQueue_reply(struct vn_cs_decoder * dec,VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)24652 static inline void vn_decode_vkGetDeviceQueue_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
24653 {
24654 VkCommandTypeEXT command_type;
24655 vn_decode_VkCommandTypeEXT(dec, &command_type);
24656 assert(command_type == VK_COMMAND_TYPE_vkGetDeviceQueue_EXT);
24657
24658 /* skip device */
24659 /* skip queueFamilyIndex */
24660 /* skip queueIndex */
24661 if (vn_decode_simple_pointer(dec)) {
24662 vn_decode_VkQueue(dec, pQueue);
24663 } else {
24664 pQueue = NULL;
24665 }
24666 }
24667
vn_sizeof_vkDeviceWaitIdle(VkDevice device)24668 static inline size_t vn_sizeof_vkDeviceWaitIdle(VkDevice device)
24669 {
24670 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT;
24671 const VkFlags cmd_flags = 0;
24672 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
24673
24674 cmd_size += vn_sizeof_VkDevice(&device);
24675
24676 return cmd_size;
24677 }
24678
vn_encode_vkDeviceWaitIdle(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device)24679 static inline void vn_encode_vkDeviceWaitIdle(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device)
24680 {
24681 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT;
24682
24683 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
24684 vn_encode_VkFlags(enc, &cmd_flags);
24685
24686 vn_encode_VkDevice(enc, &device);
24687 }
24688
vn_sizeof_vkDeviceWaitIdle_reply(VkDevice device)24689 static inline size_t vn_sizeof_vkDeviceWaitIdle_reply(VkDevice device)
24690 {
24691 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT;
24692 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
24693
24694 VkResult ret;
24695 cmd_size += vn_sizeof_VkResult(&ret);
24696 /* skip device */
24697
24698 return cmd_size;
24699 }
24700
vn_decode_vkDeviceWaitIdle_reply(struct vn_cs_decoder * dec,VkDevice device)24701 static inline VkResult vn_decode_vkDeviceWaitIdle_reply(struct vn_cs_decoder *dec, VkDevice device)
24702 {
24703 VkCommandTypeEXT command_type;
24704 vn_decode_VkCommandTypeEXT(dec, &command_type);
24705 assert(command_type == VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT);
24706
24707 VkResult ret;
24708 vn_decode_VkResult(dec, &ret);
24709 /* skip device */
24710
24711 return ret;
24712 }
24713
vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)24714 static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
24715 {
24716 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT;
24717 const VkFlags cmd_flags = 0;
24718 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
24719
24720 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
24721 cmd_size += vn_sizeof_VkFormat(&format);
24722 cmd_size += vn_sizeof_VkImageType(&type);
24723 cmd_size += vn_sizeof_VkSampleCountFlagBits(&samples);
24724 cmd_size += vn_sizeof_VkFlags(&usage);
24725 cmd_size += vn_sizeof_VkImageTiling(&tiling);
24726 cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
24727 if (pPropertyCount)
24728 cmd_size += vn_sizeof_uint32_t(pPropertyCount);
24729 if (pProperties) {
24730 cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
24731 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
24732 cmd_size += vn_sizeof_VkSparseImageFormatProperties_partial(&pProperties[i]);
24733 } else {
24734 cmd_size += vn_sizeof_array_size(0);
24735 }
24736
24737 return cmd_size;
24738 }
24739
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)24740 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)
24741 {
24742 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT;
24743
24744 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
24745 vn_encode_VkFlags(enc, &cmd_flags);
24746
24747 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
24748 vn_encode_VkFormat(enc, &format);
24749 vn_encode_VkImageType(enc, &type);
24750 vn_encode_VkSampleCountFlagBits(enc, &samples);
24751 vn_encode_VkFlags(enc, &usage);
24752 vn_encode_VkImageTiling(enc, &tiling);
24753 if (vn_encode_simple_pointer(enc, pPropertyCount))
24754 vn_encode_uint32_t(enc, pPropertyCount);
24755 if (pProperties) {
24756 vn_encode_array_size(enc, (pPropertyCount ? *pPropertyCount : 0));
24757 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
24758 vn_encode_VkSparseImageFormatProperties_partial(enc, &pProperties[i]);
24759 } else {
24760 vn_encode_array_size(enc, 0);
24761 }
24762 }
24763
vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties_reply(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)24764 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)
24765 {
24766 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT;
24767 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
24768
24769 /* skip physicalDevice */
24770 /* skip format */
24771 /* skip type */
24772 /* skip samples */
24773 /* skip usage */
24774 /* skip tiling */
24775 cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
24776 if (pPropertyCount)
24777 cmd_size += vn_sizeof_uint32_t(pPropertyCount);
24778 if (pProperties) {
24779 cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
24780 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
24781 cmd_size += vn_sizeof_VkSparseImageFormatProperties(&pProperties[i]);
24782 } else {
24783 cmd_size += vn_sizeof_array_size(0);
24784 }
24785
24786 return cmd_size;
24787 }
24788
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)24789 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)
24790 {
24791 VkCommandTypeEXT command_type;
24792 vn_decode_VkCommandTypeEXT(dec, &command_type);
24793 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT);
24794
24795 /* skip physicalDevice */
24796 /* skip format */
24797 /* skip type */
24798 /* skip samples */
24799 /* skip usage */
24800 /* skip tiling */
24801 if (vn_decode_simple_pointer(dec)) {
24802 vn_decode_uint32_t(dec, pPropertyCount);
24803 } else {
24804 pPropertyCount = NULL;
24805 }
24806 if (vn_peek_array_size(dec)) {
24807 const uint32_t iter_count = vn_decode_array_size(dec, (pPropertyCount ? *pPropertyCount : 0));
24808 for (uint32_t i = 0; i < iter_count; i++)
24809 vn_decode_VkSparseImageFormatProperties(dec, &pProperties[i]);
24810 } else {
24811 vn_decode_array_size_unchecked(dec);
24812 pProperties = NULL;
24813 }
24814 }
24815
vn_sizeof_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)24816 static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
24817 {
24818 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT;
24819 const VkFlags cmd_flags = 0;
24820 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
24821
24822 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
24823 cmd_size += vn_sizeof_simple_pointer(pFeatures);
24824 if (pFeatures)
24825 cmd_size += vn_sizeof_VkPhysicalDeviceFeatures2_partial(pFeatures);
24826
24827 return cmd_size;
24828 }
24829
vn_encode_vkGetPhysicalDeviceFeatures2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)24830 static inline void vn_encode_vkGetPhysicalDeviceFeatures2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
24831 {
24832 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT;
24833
24834 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
24835 vn_encode_VkFlags(enc, &cmd_flags);
24836
24837 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
24838 if (vn_encode_simple_pointer(enc, pFeatures))
24839 vn_encode_VkPhysicalDeviceFeatures2_partial(enc, pFeatures);
24840 }
24841
vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)24842 static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
24843 {
24844 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT;
24845 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
24846
24847 /* skip physicalDevice */
24848 cmd_size += vn_sizeof_simple_pointer(pFeatures);
24849 if (pFeatures)
24850 cmd_size += vn_sizeof_VkPhysicalDeviceFeatures2(pFeatures);
24851
24852 return cmd_size;
24853 }
24854
vn_decode_vkGetPhysicalDeviceFeatures2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)24855 static inline void vn_decode_vkGetPhysicalDeviceFeatures2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
24856 {
24857 VkCommandTypeEXT command_type;
24858 vn_decode_VkCommandTypeEXT(dec, &command_type);
24859 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT);
24860
24861 /* skip physicalDevice */
24862 if (vn_decode_simple_pointer(dec)) {
24863 vn_decode_VkPhysicalDeviceFeatures2(dec, pFeatures);
24864 } else {
24865 pFeatures = NULL;
24866 }
24867 }
24868
vn_sizeof_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)24869 static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
24870 {
24871 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT;
24872 const VkFlags cmd_flags = 0;
24873 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
24874
24875 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
24876 cmd_size += vn_sizeof_simple_pointer(pProperties);
24877 if (pProperties)
24878 cmd_size += vn_sizeof_VkPhysicalDeviceProperties2_partial(pProperties);
24879
24880 return cmd_size;
24881 }
24882
vn_encode_vkGetPhysicalDeviceProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)24883 static inline void vn_encode_vkGetPhysicalDeviceProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
24884 {
24885 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT;
24886
24887 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
24888 vn_encode_VkFlags(enc, &cmd_flags);
24889
24890 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
24891 if (vn_encode_simple_pointer(enc, pProperties))
24892 vn_encode_VkPhysicalDeviceProperties2_partial(enc, pProperties);
24893 }
24894
vn_sizeof_vkGetPhysicalDeviceProperties2_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)24895 static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
24896 {
24897 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT;
24898 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
24899
24900 /* skip physicalDevice */
24901 cmd_size += vn_sizeof_simple_pointer(pProperties);
24902 if (pProperties)
24903 cmd_size += vn_sizeof_VkPhysicalDeviceProperties2(pProperties);
24904
24905 return cmd_size;
24906 }
24907
vn_decode_vkGetPhysicalDeviceProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)24908 static inline void vn_decode_vkGetPhysicalDeviceProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
24909 {
24910 VkCommandTypeEXT command_type;
24911 vn_decode_VkCommandTypeEXT(dec, &command_type);
24912 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT);
24913
24914 /* skip physicalDevice */
24915 if (vn_decode_simple_pointer(dec)) {
24916 vn_decode_VkPhysicalDeviceProperties2(dec, pProperties);
24917 } else {
24918 pProperties = NULL;
24919 }
24920 }
24921
vn_sizeof_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)24922 static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
24923 {
24924 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT;
24925 const VkFlags cmd_flags = 0;
24926 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
24927
24928 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
24929 cmd_size += vn_sizeof_VkFormat(&format);
24930 cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
24931 if (pFormatProperties)
24932 cmd_size += vn_sizeof_VkFormatProperties2_partial(pFormatProperties);
24933
24934 return cmd_size;
24935 }
24936
vn_encode_vkGetPhysicalDeviceFormatProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)24937 static inline void vn_encode_vkGetPhysicalDeviceFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
24938 {
24939 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT;
24940
24941 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
24942 vn_encode_VkFlags(enc, &cmd_flags);
24943
24944 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
24945 vn_encode_VkFormat(enc, &format);
24946 if (vn_encode_simple_pointer(enc, pFormatProperties))
24947 vn_encode_VkFormatProperties2_partial(enc, pFormatProperties);
24948 }
24949
vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)24950 static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
24951 {
24952 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT;
24953 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
24954
24955 /* skip physicalDevice */
24956 /* skip format */
24957 cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
24958 if (pFormatProperties)
24959 cmd_size += vn_sizeof_VkFormatProperties2(pFormatProperties);
24960
24961 return cmd_size;
24962 }
24963
vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)24964 static inline void vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
24965 {
24966 VkCommandTypeEXT command_type;
24967 vn_decode_VkCommandTypeEXT(dec, &command_type);
24968 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT);
24969
24970 /* skip physicalDevice */
24971 /* skip format */
24972 if (vn_decode_simple_pointer(dec)) {
24973 vn_decode_VkFormatProperties2(dec, pFormatProperties);
24974 } else {
24975 pFormatProperties = NULL;
24976 }
24977 }
24978
vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)24979 static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
24980 {
24981 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT;
24982 const VkFlags cmd_flags = 0;
24983 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
24984
24985 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
24986 cmd_size += vn_sizeof_simple_pointer(pImageFormatInfo);
24987 if (pImageFormatInfo)
24988 cmd_size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2(pImageFormatInfo);
24989 cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
24990 if (pImageFormatProperties)
24991 cmd_size += vn_sizeof_VkImageFormatProperties2_partial(pImageFormatProperties);
24992
24993 return cmd_size;
24994 }
24995
vn_encode_vkGetPhysicalDeviceImageFormatProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)24996 static inline void vn_encode_vkGetPhysicalDeviceImageFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
24997 {
24998 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT;
24999
25000 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
25001 vn_encode_VkFlags(enc, &cmd_flags);
25002
25003 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
25004 if (vn_encode_simple_pointer(enc, pImageFormatInfo))
25005 vn_encode_VkPhysicalDeviceImageFormatInfo2(enc, pImageFormatInfo);
25006 if (vn_encode_simple_pointer(enc, pImageFormatProperties))
25007 vn_encode_VkImageFormatProperties2_partial(enc, pImageFormatProperties);
25008 }
25009
vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)25010 static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
25011 {
25012 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT;
25013 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
25014
25015 VkResult ret;
25016 cmd_size += vn_sizeof_VkResult(&ret);
25017 /* skip physicalDevice */
25018 /* skip pImageFormatInfo */
25019 cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
25020 if (pImageFormatProperties)
25021 cmd_size += vn_sizeof_VkImageFormatProperties2(pImageFormatProperties);
25022
25023 return cmd_size;
25024 }
25025
vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)25026 static inline VkResult vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
25027 {
25028 VkCommandTypeEXT command_type;
25029 vn_decode_VkCommandTypeEXT(dec, &command_type);
25030 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT);
25031
25032 VkResult ret;
25033 vn_decode_VkResult(dec, &ret);
25034 /* skip physicalDevice */
25035 /* skip pImageFormatInfo */
25036 if (vn_decode_simple_pointer(dec)) {
25037 vn_decode_VkImageFormatProperties2(dec, pImageFormatProperties);
25038 } else {
25039 pImageFormatProperties = NULL;
25040 }
25041
25042 return ret;
25043 }
25044
vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)25045 static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
25046 {
25047 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT;
25048 const VkFlags cmd_flags = 0;
25049 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
25050
25051 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
25052 cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
25053 if (pQueueFamilyPropertyCount)
25054 cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
25055 if (pQueueFamilyProperties) {
25056 cmd_size += vn_sizeof_array_size((pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
25057 for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
25058 cmd_size += vn_sizeof_VkQueueFamilyProperties2_partial(&pQueueFamilyProperties[i]);
25059 } else {
25060 cmd_size += vn_sizeof_array_size(0);
25061 }
25062
25063 return cmd_size;
25064 }
25065
vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)25066 static inline void vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
25067 {
25068 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT;
25069
25070 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
25071 vn_encode_VkFlags(enc, &cmd_flags);
25072
25073 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
25074 if (vn_encode_simple_pointer(enc, pQueueFamilyPropertyCount))
25075 vn_encode_uint32_t(enc, pQueueFamilyPropertyCount);
25076 if (pQueueFamilyProperties) {
25077 vn_encode_array_size(enc, (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
25078 for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
25079 vn_encode_VkQueueFamilyProperties2_partial(enc, &pQueueFamilyProperties[i]);
25080 } else {
25081 vn_encode_array_size(enc, 0);
25082 }
25083 }
25084
vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)25085 static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
25086 {
25087 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT;
25088 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
25089
25090 /* skip physicalDevice */
25091 cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
25092 if (pQueueFamilyPropertyCount)
25093 cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
25094 if (pQueueFamilyProperties) {
25095 cmd_size += vn_sizeof_array_size((pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
25096 for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
25097 cmd_size += vn_sizeof_VkQueueFamilyProperties2(&pQueueFamilyProperties[i]);
25098 } else {
25099 cmd_size += vn_sizeof_array_size(0);
25100 }
25101
25102 return cmd_size;
25103 }
25104
vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)25105 static inline void vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
25106 {
25107 VkCommandTypeEXT command_type;
25108 vn_decode_VkCommandTypeEXT(dec, &command_type);
25109 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT);
25110
25111 /* skip physicalDevice */
25112 if (vn_decode_simple_pointer(dec)) {
25113 vn_decode_uint32_t(dec, pQueueFamilyPropertyCount);
25114 } else {
25115 pQueueFamilyPropertyCount = NULL;
25116 }
25117 if (vn_peek_array_size(dec)) {
25118 const uint32_t iter_count = vn_decode_array_size(dec, (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
25119 for (uint32_t i = 0; i < iter_count; i++)
25120 vn_decode_VkQueueFamilyProperties2(dec, &pQueueFamilyProperties[i]);
25121 } else {
25122 vn_decode_array_size_unchecked(dec);
25123 pQueueFamilyProperties = NULL;
25124 }
25125 }
25126
vn_sizeof_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)25127 static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
25128 {
25129 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT;
25130 const VkFlags cmd_flags = 0;
25131 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
25132
25133 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
25134 cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
25135 if (pMemoryProperties)
25136 cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_partial(pMemoryProperties);
25137
25138 return cmd_size;
25139 }
25140
vn_encode_vkGetPhysicalDeviceMemoryProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)25141 static inline void vn_encode_vkGetPhysicalDeviceMemoryProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
25142 {
25143 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT;
25144
25145 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
25146 vn_encode_VkFlags(enc, &cmd_flags);
25147
25148 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
25149 if (vn_encode_simple_pointer(enc, pMemoryProperties))
25150 vn_encode_VkPhysicalDeviceMemoryProperties2_partial(enc, pMemoryProperties);
25151 }
25152
vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)25153 static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
25154 {
25155 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT;
25156 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
25157
25158 /* skip physicalDevice */
25159 cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
25160 if (pMemoryProperties)
25161 cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties2(pMemoryProperties);
25162
25163 return cmd_size;
25164 }
25165
vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)25166 static inline void vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
25167 {
25168 VkCommandTypeEXT command_type;
25169 vn_decode_VkCommandTypeEXT(dec, &command_type);
25170 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT);
25171
25172 /* skip physicalDevice */
25173 if (vn_decode_simple_pointer(dec)) {
25174 vn_decode_VkPhysicalDeviceMemoryProperties2(dec, pMemoryProperties);
25175 } else {
25176 pMemoryProperties = NULL;
25177 }
25178 }
25179
vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)25180 static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
25181 {
25182 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT;
25183 const VkFlags cmd_flags = 0;
25184 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
25185
25186 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
25187 cmd_size += vn_sizeof_simple_pointer(pFormatInfo);
25188 if (pFormatInfo)
25189 cmd_size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2(pFormatInfo);
25190 cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
25191 if (pPropertyCount)
25192 cmd_size += vn_sizeof_uint32_t(pPropertyCount);
25193 if (pProperties) {
25194 cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
25195 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
25196 cmd_size += vn_sizeof_VkSparseImageFormatProperties2_partial(&pProperties[i]);
25197 } else {
25198 cmd_size += vn_sizeof_array_size(0);
25199 }
25200
25201 return cmd_size;
25202 }
25203
vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)25204 static inline void vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
25205 {
25206 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT;
25207
25208 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
25209 vn_encode_VkFlags(enc, &cmd_flags);
25210
25211 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
25212 if (vn_encode_simple_pointer(enc, pFormatInfo))
25213 vn_encode_VkPhysicalDeviceSparseImageFormatInfo2(enc, pFormatInfo);
25214 if (vn_encode_simple_pointer(enc, pPropertyCount))
25215 vn_encode_uint32_t(enc, pPropertyCount);
25216 if (pProperties) {
25217 vn_encode_array_size(enc, (pPropertyCount ? *pPropertyCount : 0));
25218 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
25219 vn_encode_VkSparseImageFormatProperties2_partial(enc, &pProperties[i]);
25220 } else {
25221 vn_encode_array_size(enc, 0);
25222 }
25223 }
25224
vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)25225 static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
25226 {
25227 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT;
25228 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
25229
25230 /* skip physicalDevice */
25231 /* skip pFormatInfo */
25232 cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
25233 if (pPropertyCount)
25234 cmd_size += vn_sizeof_uint32_t(pPropertyCount);
25235 if (pProperties) {
25236 cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
25237 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
25238 cmd_size += vn_sizeof_VkSparseImageFormatProperties2(&pProperties[i]);
25239 } else {
25240 cmd_size += vn_sizeof_array_size(0);
25241 }
25242
25243 return cmd_size;
25244 }
25245
vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)25246 static inline void vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
25247 {
25248 VkCommandTypeEXT command_type;
25249 vn_decode_VkCommandTypeEXT(dec, &command_type);
25250 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT);
25251
25252 /* skip physicalDevice */
25253 /* skip pFormatInfo */
25254 if (vn_decode_simple_pointer(dec)) {
25255 vn_decode_uint32_t(dec, pPropertyCount);
25256 } else {
25257 pPropertyCount = NULL;
25258 }
25259 if (vn_peek_array_size(dec)) {
25260 const uint32_t iter_count = vn_decode_array_size(dec, (pPropertyCount ? *pPropertyCount : 0));
25261 for (uint32_t i = 0; i < iter_count; i++)
25262 vn_decode_VkSparseImageFormatProperties2(dec, &pProperties[i]);
25263 } else {
25264 vn_decode_array_size_unchecked(dec);
25265 pProperties = NULL;
25266 }
25267 }
25268
vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)25269 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
25270 {
25271 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT;
25272 const VkFlags cmd_flags = 0;
25273 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
25274
25275 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
25276 cmd_size += vn_sizeof_simple_pointer(pExternalBufferInfo);
25277 if (pExternalBufferInfo)
25278 cmd_size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo(pExternalBufferInfo);
25279 cmd_size += vn_sizeof_simple_pointer(pExternalBufferProperties);
25280 if (pExternalBufferProperties)
25281 cmd_size += vn_sizeof_VkExternalBufferProperties_partial(pExternalBufferProperties);
25282
25283 return cmd_size;
25284 }
25285
vn_encode_vkGetPhysicalDeviceExternalBufferProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)25286 static inline void vn_encode_vkGetPhysicalDeviceExternalBufferProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
25287 {
25288 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT;
25289
25290 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
25291 vn_encode_VkFlags(enc, &cmd_flags);
25292
25293 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
25294 if (vn_encode_simple_pointer(enc, pExternalBufferInfo))
25295 vn_encode_VkPhysicalDeviceExternalBufferInfo(enc, pExternalBufferInfo);
25296 if (vn_encode_simple_pointer(enc, pExternalBufferProperties))
25297 vn_encode_VkExternalBufferProperties_partial(enc, pExternalBufferProperties);
25298 }
25299
vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)25300 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
25301 {
25302 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT;
25303 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
25304
25305 /* skip physicalDevice */
25306 /* skip pExternalBufferInfo */
25307 cmd_size += vn_sizeof_simple_pointer(pExternalBufferProperties);
25308 if (pExternalBufferProperties)
25309 cmd_size += vn_sizeof_VkExternalBufferProperties(pExternalBufferProperties);
25310
25311 return cmd_size;
25312 }
25313
vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)25314 static inline void vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
25315 {
25316 VkCommandTypeEXT command_type;
25317 vn_decode_VkCommandTypeEXT(dec, &command_type);
25318 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT);
25319
25320 /* skip physicalDevice */
25321 /* skip pExternalBufferInfo */
25322 if (vn_decode_simple_pointer(dec)) {
25323 vn_decode_VkExternalBufferProperties(dec, pExternalBufferProperties);
25324 } else {
25325 pExternalBufferProperties = NULL;
25326 }
25327 }
25328
vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)25329 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
25330 {
25331 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT;
25332 const VkFlags cmd_flags = 0;
25333 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
25334
25335 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
25336 cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreInfo);
25337 if (pExternalSemaphoreInfo)
25338 cmd_size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo(pExternalSemaphoreInfo);
25339 cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreProperties);
25340 if (pExternalSemaphoreProperties)
25341 cmd_size += vn_sizeof_VkExternalSemaphoreProperties_partial(pExternalSemaphoreProperties);
25342
25343 return cmd_size;
25344 }
25345
vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)25346 static inline void vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
25347 {
25348 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT;
25349
25350 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
25351 vn_encode_VkFlags(enc, &cmd_flags);
25352
25353 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
25354 if (vn_encode_simple_pointer(enc, pExternalSemaphoreInfo))
25355 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo(enc, pExternalSemaphoreInfo);
25356 if (vn_encode_simple_pointer(enc, pExternalSemaphoreProperties))
25357 vn_encode_VkExternalSemaphoreProperties_partial(enc, pExternalSemaphoreProperties);
25358 }
25359
vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)25360 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
25361 {
25362 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT;
25363 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
25364
25365 /* skip physicalDevice */
25366 /* skip pExternalSemaphoreInfo */
25367 cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreProperties);
25368 if (pExternalSemaphoreProperties)
25369 cmd_size += vn_sizeof_VkExternalSemaphoreProperties(pExternalSemaphoreProperties);
25370
25371 return cmd_size;
25372 }
25373
vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)25374 static inline void vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
25375 {
25376 VkCommandTypeEXT command_type;
25377 vn_decode_VkCommandTypeEXT(dec, &command_type);
25378 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT);
25379
25380 /* skip physicalDevice */
25381 /* skip pExternalSemaphoreInfo */
25382 if (vn_decode_simple_pointer(dec)) {
25383 vn_decode_VkExternalSemaphoreProperties(dec, pExternalSemaphoreProperties);
25384 } else {
25385 pExternalSemaphoreProperties = NULL;
25386 }
25387 }
25388
vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)25389 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
25390 {
25391 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT;
25392 const VkFlags cmd_flags = 0;
25393 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
25394
25395 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
25396 cmd_size += vn_sizeof_simple_pointer(pExternalFenceInfo);
25397 if (pExternalFenceInfo)
25398 cmd_size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo(pExternalFenceInfo);
25399 cmd_size += vn_sizeof_simple_pointer(pExternalFenceProperties);
25400 if (pExternalFenceProperties)
25401 cmd_size += vn_sizeof_VkExternalFenceProperties_partial(pExternalFenceProperties);
25402
25403 return cmd_size;
25404 }
25405
vn_encode_vkGetPhysicalDeviceExternalFenceProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)25406 static inline void vn_encode_vkGetPhysicalDeviceExternalFenceProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
25407 {
25408 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT;
25409
25410 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
25411 vn_encode_VkFlags(enc, &cmd_flags);
25412
25413 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
25414 if (vn_encode_simple_pointer(enc, pExternalFenceInfo))
25415 vn_encode_VkPhysicalDeviceExternalFenceInfo(enc, pExternalFenceInfo);
25416 if (vn_encode_simple_pointer(enc, pExternalFenceProperties))
25417 vn_encode_VkExternalFenceProperties_partial(enc, pExternalFenceProperties);
25418 }
25419
vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)25420 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
25421 {
25422 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT;
25423 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
25424
25425 /* skip physicalDevice */
25426 /* skip pExternalFenceInfo */
25427 cmd_size += vn_sizeof_simple_pointer(pExternalFenceProperties);
25428 if (pExternalFenceProperties)
25429 cmd_size += vn_sizeof_VkExternalFenceProperties(pExternalFenceProperties);
25430
25431 return cmd_size;
25432 }
25433
vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)25434 static inline void vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
25435 {
25436 VkCommandTypeEXT command_type;
25437 vn_decode_VkCommandTypeEXT(dec, &command_type);
25438 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT);
25439
25440 /* skip physicalDevice */
25441 /* skip pExternalFenceInfo */
25442 if (vn_decode_simple_pointer(dec)) {
25443 vn_decode_VkExternalFenceProperties(dec, pExternalFenceProperties);
25444 } else {
25445 pExternalFenceProperties = NULL;
25446 }
25447 }
25448
vn_sizeof_vkEnumeratePhysicalDeviceGroups(VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)25449 static inline size_t vn_sizeof_vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
25450 {
25451 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT;
25452 const VkFlags cmd_flags = 0;
25453 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
25454
25455 cmd_size += vn_sizeof_VkInstance(&instance);
25456 cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceGroupCount);
25457 if (pPhysicalDeviceGroupCount)
25458 cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceGroupCount);
25459 if (pPhysicalDeviceGroupProperties) {
25460 cmd_size += vn_sizeof_array_size((pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0));
25461 for (uint32_t i = 0; i < (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0); i++)
25462 cmd_size += vn_sizeof_VkPhysicalDeviceGroupProperties_partial(&pPhysicalDeviceGroupProperties[i]);
25463 } else {
25464 cmd_size += vn_sizeof_array_size(0);
25465 }
25466
25467 return cmd_size;
25468 }
25469
vn_encode_vkEnumeratePhysicalDeviceGroups(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)25470 static inline void vn_encode_vkEnumeratePhysicalDeviceGroups(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
25471 {
25472 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT;
25473
25474 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
25475 vn_encode_VkFlags(enc, &cmd_flags);
25476
25477 vn_encode_VkInstance(enc, &instance);
25478 if (vn_encode_simple_pointer(enc, pPhysicalDeviceGroupCount))
25479 vn_encode_uint32_t(enc, pPhysicalDeviceGroupCount);
25480 if (pPhysicalDeviceGroupProperties) {
25481 vn_encode_array_size(enc, (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0));
25482 for (uint32_t i = 0; i < (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0); i++)
25483 vn_encode_VkPhysicalDeviceGroupProperties_partial(enc, &pPhysicalDeviceGroupProperties[i]);
25484 } else {
25485 vn_encode_array_size(enc, 0);
25486 }
25487 }
25488
vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)25489 static inline size_t vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
25490 {
25491 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT;
25492 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
25493
25494 VkResult ret;
25495 cmd_size += vn_sizeof_VkResult(&ret);
25496 /* skip instance */
25497 cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceGroupCount);
25498 if (pPhysicalDeviceGroupCount)
25499 cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceGroupCount);
25500 if (pPhysicalDeviceGroupProperties) {
25501 cmd_size += vn_sizeof_array_size((pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0));
25502 for (uint32_t i = 0; i < (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0); i++)
25503 cmd_size += vn_sizeof_VkPhysicalDeviceGroupProperties(&pPhysicalDeviceGroupProperties[i]);
25504 } else {
25505 cmd_size += vn_sizeof_array_size(0);
25506 }
25507
25508 return cmd_size;
25509 }
25510
vn_decode_vkEnumeratePhysicalDeviceGroups_reply(struct vn_cs_decoder * dec,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)25511 static inline VkResult vn_decode_vkEnumeratePhysicalDeviceGroups_reply(struct vn_cs_decoder *dec, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
25512 {
25513 VkCommandTypeEXT command_type;
25514 vn_decode_VkCommandTypeEXT(dec, &command_type);
25515 assert(command_type == VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT);
25516
25517 VkResult ret;
25518 vn_decode_VkResult(dec, &ret);
25519 /* skip instance */
25520 if (vn_decode_simple_pointer(dec)) {
25521 vn_decode_uint32_t(dec, pPhysicalDeviceGroupCount);
25522 } else {
25523 pPhysicalDeviceGroupCount = NULL;
25524 }
25525 if (vn_peek_array_size(dec)) {
25526 const uint32_t iter_count = vn_decode_array_size(dec, (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0));
25527 for (uint32_t i = 0; i < iter_count; i++)
25528 vn_decode_VkPhysicalDeviceGroupProperties(dec, &pPhysicalDeviceGroupProperties[i]);
25529 } else {
25530 vn_decode_array_size_unchecked(dec);
25531 pPhysicalDeviceGroupProperties = NULL;
25532 }
25533
25534 return ret;
25535 }
25536
vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)25537 static inline size_t vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
25538 {
25539 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT;
25540 const VkFlags cmd_flags = 0;
25541 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
25542
25543 cmd_size += vn_sizeof_VkDevice(&device);
25544 cmd_size += vn_sizeof_uint32_t(&heapIndex);
25545 cmd_size += vn_sizeof_uint32_t(&localDeviceIndex);
25546 cmd_size += vn_sizeof_uint32_t(&remoteDeviceIndex);
25547 cmd_size += vn_sizeof_simple_pointer(pPeerMemoryFeatures); /* out */
25548
25549 return cmd_size;
25550 }
25551
vn_encode_vkGetDeviceGroupPeerMemoryFeatures(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)25552 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)
25553 {
25554 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT;
25555
25556 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
25557 vn_encode_VkFlags(enc, &cmd_flags);
25558
25559 vn_encode_VkDevice(enc, &device);
25560 vn_encode_uint32_t(enc, &heapIndex);
25561 vn_encode_uint32_t(enc, &localDeviceIndex);
25562 vn_encode_uint32_t(enc, &remoteDeviceIndex);
25563 vn_encode_simple_pointer(enc, pPeerMemoryFeatures); /* out */
25564 }
25565
vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)25566 static inline size_t vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
25567 {
25568 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT;
25569 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
25570
25571 /* skip device */
25572 /* skip heapIndex */
25573 /* skip localDeviceIndex */
25574 /* skip remoteDeviceIndex */
25575 cmd_size += vn_sizeof_simple_pointer(pPeerMemoryFeatures);
25576 if (pPeerMemoryFeatures)
25577 cmd_size += vn_sizeof_VkFlags(pPeerMemoryFeatures);
25578
25579 return cmd_size;
25580 }
25581
vn_decode_vkGetDeviceGroupPeerMemoryFeatures_reply(struct vn_cs_decoder * dec,VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)25582 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)
25583 {
25584 VkCommandTypeEXT command_type;
25585 vn_decode_VkCommandTypeEXT(dec, &command_type);
25586 assert(command_type == VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT);
25587
25588 /* skip device */
25589 /* skip heapIndex */
25590 /* skip localDeviceIndex */
25591 /* skip remoteDeviceIndex */
25592 if (vn_decode_simple_pointer(dec)) {
25593 vn_decode_VkFlags(dec, pPeerMemoryFeatures);
25594 } else {
25595 pPeerMemoryFeatures = NULL;
25596 }
25597 }
25598
vn_sizeof_vkGetDeviceQueue2(VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)25599 static inline size_t vn_sizeof_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
25600 {
25601 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT;
25602 const VkFlags cmd_flags = 0;
25603 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
25604
25605 cmd_size += vn_sizeof_VkDevice(&device);
25606 cmd_size += vn_sizeof_simple_pointer(pQueueInfo);
25607 if (pQueueInfo)
25608 cmd_size += vn_sizeof_VkDeviceQueueInfo2(pQueueInfo);
25609 cmd_size += vn_sizeof_simple_pointer(pQueue);
25610 if (pQueue)
25611 cmd_size += vn_sizeof_VkQueue(pQueue);
25612
25613 return cmd_size;
25614 }
25615
vn_encode_vkGetDeviceQueue2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)25616 static inline void vn_encode_vkGetDeviceQueue2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
25617 {
25618 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT;
25619
25620 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
25621 vn_encode_VkFlags(enc, &cmd_flags);
25622
25623 vn_encode_VkDevice(enc, &device);
25624 if (vn_encode_simple_pointer(enc, pQueueInfo))
25625 vn_encode_VkDeviceQueueInfo2(enc, pQueueInfo);
25626 if (vn_encode_simple_pointer(enc, pQueue))
25627 vn_encode_VkQueue(enc, pQueue);
25628 }
25629
vn_sizeof_vkGetDeviceQueue2_reply(VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)25630 static inline size_t vn_sizeof_vkGetDeviceQueue2_reply(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
25631 {
25632 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT;
25633 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
25634
25635 /* skip device */
25636 /* skip pQueueInfo */
25637 cmd_size += vn_sizeof_simple_pointer(pQueue);
25638 if (pQueue)
25639 cmd_size += vn_sizeof_VkQueue(pQueue);
25640
25641 return cmd_size;
25642 }
25643
vn_decode_vkGetDeviceQueue2_reply(struct vn_cs_decoder * dec,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)25644 static inline void vn_decode_vkGetDeviceQueue2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
25645 {
25646 VkCommandTypeEXT command_type;
25647 vn_decode_VkCommandTypeEXT(dec, &command_type);
25648 assert(command_type == VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT);
25649
25650 /* skip device */
25651 /* skip pQueueInfo */
25652 if (vn_decode_simple_pointer(dec)) {
25653 vn_decode_VkQueue(dec, pQueue);
25654 } else {
25655 pQueue = NULL;
25656 }
25657 }
25658
vn_sizeof_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice,uint32_t * pTimeDomainCount,VkTimeDomainEXT * pTimeDomains)25659 static inline size_t vn_sizeof_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains)
25660 {
25661 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_EXT;
25662 const VkFlags cmd_flags = 0;
25663 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
25664
25665 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
25666 cmd_size += vn_sizeof_simple_pointer(pTimeDomainCount);
25667 if (pTimeDomainCount)
25668 cmd_size += vn_sizeof_uint32_t(pTimeDomainCount);
25669 cmd_size += vn_sizeof_simple_pointer(pTimeDomains); /* out */
25670
25671 return cmd_size;
25672 }
25673
vn_encode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pTimeDomainCount,VkTimeDomainEXT * pTimeDomains)25674 static inline void vn_encode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains)
25675 {
25676 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_EXT;
25677
25678 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
25679 vn_encode_VkFlags(enc, &cmd_flags);
25680
25681 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
25682 if (vn_encode_simple_pointer(enc, pTimeDomainCount))
25683 vn_encode_uint32_t(enc, pTimeDomainCount);
25684 vn_encode_array_size(enc, pTimeDomains ? (pTimeDomainCount ? *pTimeDomainCount : 0) : 0); /* out */
25685 }
25686
vn_sizeof_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_reply(VkPhysicalDevice physicalDevice,uint32_t * pTimeDomainCount,VkTimeDomainEXT * pTimeDomains)25687 static inline size_t vn_sizeof_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_reply(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains)
25688 {
25689 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_EXT;
25690 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
25691
25692 VkResult ret;
25693 cmd_size += vn_sizeof_VkResult(&ret);
25694 /* skip physicalDevice */
25695 cmd_size += vn_sizeof_simple_pointer(pTimeDomainCount);
25696 if (pTimeDomainCount)
25697 cmd_size += vn_sizeof_uint32_t(pTimeDomainCount);
25698 if (pTimeDomains) {
25699 cmd_size += vn_sizeof_array_size((pTimeDomainCount ? *pTimeDomainCount : 0));
25700 cmd_size += vn_sizeof_VkTimeDomainEXT_array(pTimeDomains, (pTimeDomainCount ? *pTimeDomainCount : 0));
25701 } else {
25702 cmd_size += vn_sizeof_array_size(0);
25703 }
25704
25705 return cmd_size;
25706 }
25707
vn_decode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,uint32_t * pTimeDomainCount,VkTimeDomainEXT * pTimeDomains)25708 static inline VkResult vn_decode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains)
25709 {
25710 VkCommandTypeEXT command_type;
25711 vn_decode_VkCommandTypeEXT(dec, &command_type);
25712 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_EXT);
25713
25714 VkResult ret;
25715 vn_decode_VkResult(dec, &ret);
25716 /* skip physicalDevice */
25717 if (vn_decode_simple_pointer(dec)) {
25718 vn_decode_uint32_t(dec, pTimeDomainCount);
25719 } else {
25720 pTimeDomainCount = NULL;
25721 }
25722 if (vn_peek_array_size(dec)) {
25723 const size_t array_size = vn_decode_array_size(dec, (pTimeDomainCount ? *pTimeDomainCount : 0));
25724 vn_decode_VkTimeDomainEXT_array(dec, pTimeDomains, array_size);
25725 } else {
25726 vn_decode_array_size_unchecked(dec);
25727 pTimeDomains = NULL;
25728 }
25729
25730 return ret;
25731 }
25732
vn_sizeof_vkGetCalibratedTimestampsEXT(VkDevice device,uint32_t timestampCount,const VkCalibratedTimestampInfoEXT * pTimestampInfos,uint64_t * pTimestamps,uint64_t * pMaxDeviation)25733 static inline size_t vn_sizeof_vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation)
25734 {
25735 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetCalibratedTimestampsEXT_EXT;
25736 const VkFlags cmd_flags = 0;
25737 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
25738
25739 cmd_size += vn_sizeof_VkDevice(&device);
25740 cmd_size += vn_sizeof_uint32_t(×tampCount);
25741 if (pTimestampInfos) {
25742 cmd_size += vn_sizeof_array_size(timestampCount);
25743 for (uint32_t i = 0; i < timestampCount; i++)
25744 cmd_size += vn_sizeof_VkCalibratedTimestampInfoEXT(&pTimestampInfos[i]);
25745 } else {
25746 cmd_size += vn_sizeof_array_size(0);
25747 }
25748 cmd_size += vn_sizeof_simple_pointer(pTimestamps); /* out */
25749 cmd_size += vn_sizeof_simple_pointer(pMaxDeviation); /* out */
25750
25751 return cmd_size;
25752 }
25753
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)25754 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)
25755 {
25756 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetCalibratedTimestampsEXT_EXT;
25757
25758 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
25759 vn_encode_VkFlags(enc, &cmd_flags);
25760
25761 vn_encode_VkDevice(enc, &device);
25762 vn_encode_uint32_t(enc, ×tampCount);
25763 if (pTimestampInfos) {
25764 vn_encode_array_size(enc, timestampCount);
25765 for (uint32_t i = 0; i < timestampCount; i++)
25766 vn_encode_VkCalibratedTimestampInfoEXT(enc, &pTimestampInfos[i]);
25767 } else {
25768 vn_encode_array_size(enc, 0);
25769 }
25770 vn_encode_array_size(enc, pTimestamps ? timestampCount : 0); /* out */
25771 vn_encode_simple_pointer(enc, pMaxDeviation); /* out */
25772 }
25773
vn_sizeof_vkGetCalibratedTimestampsEXT_reply(VkDevice device,uint32_t timestampCount,const VkCalibratedTimestampInfoEXT * pTimestampInfos,uint64_t * pTimestamps,uint64_t * pMaxDeviation)25774 static inline size_t vn_sizeof_vkGetCalibratedTimestampsEXT_reply(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation)
25775 {
25776 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetCalibratedTimestampsEXT_EXT;
25777 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
25778
25779 VkResult ret;
25780 cmd_size += vn_sizeof_VkResult(&ret);
25781 /* skip device */
25782 /* skip timestampCount */
25783 /* skip pTimestampInfos */
25784 if (pTimestamps) {
25785 cmd_size += vn_sizeof_array_size(timestampCount);
25786 cmd_size += vn_sizeof_uint64_t_array(pTimestamps, timestampCount);
25787 } else {
25788 cmd_size += vn_sizeof_array_size(0);
25789 }
25790 cmd_size += vn_sizeof_simple_pointer(pMaxDeviation);
25791 if (pMaxDeviation)
25792 cmd_size += vn_sizeof_uint64_t(pMaxDeviation);
25793
25794 return cmd_size;
25795 }
25796
vn_decode_vkGetCalibratedTimestampsEXT_reply(struct vn_cs_decoder * dec,VkDevice device,uint32_t timestampCount,const VkCalibratedTimestampInfoEXT * pTimestampInfos,uint64_t * pTimestamps,uint64_t * pMaxDeviation)25797 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)
25798 {
25799 VkCommandTypeEXT command_type;
25800 vn_decode_VkCommandTypeEXT(dec, &command_type);
25801 assert(command_type == VK_COMMAND_TYPE_vkGetCalibratedTimestampsEXT_EXT);
25802
25803 VkResult ret;
25804 vn_decode_VkResult(dec, &ret);
25805 /* skip device */
25806 /* skip timestampCount */
25807 /* skip pTimestampInfos */
25808 if (vn_peek_array_size(dec)) {
25809 const size_t array_size = vn_decode_array_size(dec, timestampCount);
25810 vn_decode_uint64_t_array(dec, pTimestamps, array_size);
25811 } else {
25812 vn_decode_array_size_unchecked(dec);
25813 pTimestamps = NULL;
25814 }
25815 if (vn_decode_simple_pointer(dec)) {
25816 vn_decode_uint64_t(dec, pMaxDeviation);
25817 } else {
25818 pMaxDeviation = NULL;
25819 }
25820
25821 return ret;
25822 }
25823
vn_sizeof_vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice,uint32_t * pToolCount,VkPhysicalDeviceToolProperties * pToolProperties)25824 static inline size_t vn_sizeof_vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties)
25825 {
25826 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceToolProperties_EXT;
25827 const VkFlags cmd_flags = 0;
25828 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
25829
25830 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
25831 cmd_size += vn_sizeof_simple_pointer(pToolCount);
25832 if (pToolCount)
25833 cmd_size += vn_sizeof_uint32_t(pToolCount);
25834 if (pToolProperties) {
25835 cmd_size += vn_sizeof_array_size((pToolCount ? *pToolCount : 0));
25836 for (uint32_t i = 0; i < (pToolCount ? *pToolCount : 0); i++)
25837 cmd_size += vn_sizeof_VkPhysicalDeviceToolProperties_partial(&pToolProperties[i]);
25838 } else {
25839 cmd_size += vn_sizeof_array_size(0);
25840 }
25841
25842 return cmd_size;
25843 }
25844
vn_encode_vkGetPhysicalDeviceToolProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pToolCount,VkPhysicalDeviceToolProperties * pToolProperties)25845 static inline void vn_encode_vkGetPhysicalDeviceToolProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties)
25846 {
25847 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceToolProperties_EXT;
25848
25849 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
25850 vn_encode_VkFlags(enc, &cmd_flags);
25851
25852 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
25853 if (vn_encode_simple_pointer(enc, pToolCount))
25854 vn_encode_uint32_t(enc, pToolCount);
25855 if (pToolProperties) {
25856 vn_encode_array_size(enc, (pToolCount ? *pToolCount : 0));
25857 for (uint32_t i = 0; i < (pToolCount ? *pToolCount : 0); i++)
25858 vn_encode_VkPhysicalDeviceToolProperties_partial(enc, &pToolProperties[i]);
25859 } else {
25860 vn_encode_array_size(enc, 0);
25861 }
25862 }
25863
vn_sizeof_vkGetPhysicalDeviceToolProperties_reply(VkPhysicalDevice physicalDevice,uint32_t * pToolCount,VkPhysicalDeviceToolProperties * pToolProperties)25864 static inline size_t vn_sizeof_vkGetPhysicalDeviceToolProperties_reply(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties)
25865 {
25866 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceToolProperties_EXT;
25867 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
25868
25869 VkResult ret;
25870 cmd_size += vn_sizeof_VkResult(&ret);
25871 /* skip physicalDevice */
25872 cmd_size += vn_sizeof_simple_pointer(pToolCount);
25873 if (pToolCount)
25874 cmd_size += vn_sizeof_uint32_t(pToolCount);
25875 if (pToolProperties) {
25876 cmd_size += vn_sizeof_array_size((pToolCount ? *pToolCount : 0));
25877 for (uint32_t i = 0; i < (pToolCount ? *pToolCount : 0); i++)
25878 cmd_size += vn_sizeof_VkPhysicalDeviceToolProperties(&pToolProperties[i]);
25879 } else {
25880 cmd_size += vn_sizeof_array_size(0);
25881 }
25882
25883 return cmd_size;
25884 }
25885
vn_decode_vkGetPhysicalDeviceToolProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,uint32_t * pToolCount,VkPhysicalDeviceToolProperties * pToolProperties)25886 static inline VkResult vn_decode_vkGetPhysicalDeviceToolProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties)
25887 {
25888 VkCommandTypeEXT command_type;
25889 vn_decode_VkCommandTypeEXT(dec, &command_type);
25890 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceToolProperties_EXT);
25891
25892 VkResult ret;
25893 vn_decode_VkResult(dec, &ret);
25894 /* skip physicalDevice */
25895 if (vn_decode_simple_pointer(dec)) {
25896 vn_decode_uint32_t(dec, pToolCount);
25897 } else {
25898 pToolCount = NULL;
25899 }
25900 if (vn_peek_array_size(dec)) {
25901 const uint32_t iter_count = vn_decode_array_size(dec, (pToolCount ? *pToolCount : 0));
25902 for (uint32_t i = 0; i < iter_count; i++)
25903 vn_decode_VkPhysicalDeviceToolProperties(dec, &pToolProperties[i]);
25904 } else {
25905 vn_decode_array_size_unchecked(dec);
25906 pToolProperties = NULL;
25907 }
25908
25909 return ret;
25910 }
25911
vn_sizeof_vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice,uint32_t * pFragmentShadingRateCount,VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates)25912 static inline size_t vn_sizeof_vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates)
25913 {
25914 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFragmentShadingRatesKHR_EXT;
25915 const VkFlags cmd_flags = 0;
25916 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
25917
25918 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
25919 cmd_size += vn_sizeof_simple_pointer(pFragmentShadingRateCount);
25920 if (pFragmentShadingRateCount)
25921 cmd_size += vn_sizeof_uint32_t(pFragmentShadingRateCount);
25922 if (pFragmentShadingRates) {
25923 cmd_size += vn_sizeof_array_size((pFragmentShadingRateCount ? *pFragmentShadingRateCount : 0));
25924 for (uint32_t i = 0; i < (pFragmentShadingRateCount ? *pFragmentShadingRateCount : 0); i++)
25925 cmd_size += vn_sizeof_VkPhysicalDeviceFragmentShadingRateKHR_partial(&pFragmentShadingRates[i]);
25926 } else {
25927 cmd_size += vn_sizeof_array_size(0);
25928 }
25929
25930 return cmd_size;
25931 }
25932
vn_encode_vkGetPhysicalDeviceFragmentShadingRatesKHR(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pFragmentShadingRateCount,VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates)25933 static inline void vn_encode_vkGetPhysicalDeviceFragmentShadingRatesKHR(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates)
25934 {
25935 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFragmentShadingRatesKHR_EXT;
25936
25937 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
25938 vn_encode_VkFlags(enc, &cmd_flags);
25939
25940 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
25941 if (vn_encode_simple_pointer(enc, pFragmentShadingRateCount))
25942 vn_encode_uint32_t(enc, pFragmentShadingRateCount);
25943 if (pFragmentShadingRates) {
25944 vn_encode_array_size(enc, (pFragmentShadingRateCount ? *pFragmentShadingRateCount : 0));
25945 for (uint32_t i = 0; i < (pFragmentShadingRateCount ? *pFragmentShadingRateCount : 0); i++)
25946 vn_encode_VkPhysicalDeviceFragmentShadingRateKHR_partial(enc, &pFragmentShadingRates[i]);
25947 } else {
25948 vn_encode_array_size(enc, 0);
25949 }
25950 }
25951
vn_sizeof_vkGetPhysicalDeviceFragmentShadingRatesKHR_reply(VkPhysicalDevice physicalDevice,uint32_t * pFragmentShadingRateCount,VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates)25952 static inline size_t vn_sizeof_vkGetPhysicalDeviceFragmentShadingRatesKHR_reply(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates)
25953 {
25954 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFragmentShadingRatesKHR_EXT;
25955 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
25956
25957 VkResult ret;
25958 cmd_size += vn_sizeof_VkResult(&ret);
25959 /* skip physicalDevice */
25960 cmd_size += vn_sizeof_simple_pointer(pFragmentShadingRateCount);
25961 if (pFragmentShadingRateCount)
25962 cmd_size += vn_sizeof_uint32_t(pFragmentShadingRateCount);
25963 if (pFragmentShadingRates) {
25964 cmd_size += vn_sizeof_array_size((pFragmentShadingRateCount ? *pFragmentShadingRateCount : 0));
25965 for (uint32_t i = 0; i < (pFragmentShadingRateCount ? *pFragmentShadingRateCount : 0); i++)
25966 cmd_size += vn_sizeof_VkPhysicalDeviceFragmentShadingRateKHR(&pFragmentShadingRates[i]);
25967 } else {
25968 cmd_size += vn_sizeof_array_size(0);
25969 }
25970
25971 return cmd_size;
25972 }
25973
vn_decode_vkGetPhysicalDeviceFragmentShadingRatesKHR_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,uint32_t * pFragmentShadingRateCount,VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates)25974 static inline VkResult vn_decode_vkGetPhysicalDeviceFragmentShadingRatesKHR_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates)
25975 {
25976 VkCommandTypeEXT command_type;
25977 vn_decode_VkCommandTypeEXT(dec, &command_type);
25978 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFragmentShadingRatesKHR_EXT);
25979
25980 VkResult ret;
25981 vn_decode_VkResult(dec, &ret);
25982 /* skip physicalDevice */
25983 if (vn_decode_simple_pointer(dec)) {
25984 vn_decode_uint32_t(dec, pFragmentShadingRateCount);
25985 } else {
25986 pFragmentShadingRateCount = NULL;
25987 }
25988 if (vn_peek_array_size(dec)) {
25989 const uint32_t iter_count = vn_decode_array_size(dec, (pFragmentShadingRateCount ? *pFragmentShadingRateCount : 0));
25990 for (uint32_t i = 0; i < iter_count; i++)
25991 vn_decode_VkPhysicalDeviceFragmentShadingRateKHR(dec, &pFragmentShadingRates[i]);
25992 } else {
25993 vn_decode_array_size_unchecked(dec);
25994 pFragmentShadingRates = NULL;
25995 }
25996
25997 return ret;
25998 }
25999
vn_submit_vkEnumeratePhysicalDevices(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices,struct vn_ring_submit_command * submit)26000 static inline void vn_submit_vkEnumeratePhysicalDevices(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices, struct vn_ring_submit_command *submit)
26001 {
26002 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26003 void *cmd_data = local_cmd_data;
26004 size_t cmd_size = vn_sizeof_vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
26005 if (cmd_size > sizeof(local_cmd_data)) {
26006 cmd_data = malloc(cmd_size);
26007 if (!cmd_data)
26008 cmd_size = 0;
26009 }
26010 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumeratePhysicalDevices_reply(instance, pPhysicalDeviceCount, pPhysicalDevices) : 0;
26011
26012 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26013 if (cmd_size) {
26014 vn_encode_vkEnumeratePhysicalDevices(enc, cmd_flags, instance, pPhysicalDeviceCount, pPhysicalDevices);
26015 vn_ring_submit_command(vn_ring, submit);
26016 if (cmd_data != local_cmd_data)
26017 free(cmd_data);
26018 }
26019 }
26020
vn_submit_vkGetPhysicalDeviceProperties(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties,struct vn_ring_submit_command * submit)26021 static inline void vn_submit_vkGetPhysicalDeviceProperties(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties, struct vn_ring_submit_command *submit)
26022 {
26023 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26024 void *cmd_data = local_cmd_data;
26025 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceProperties(physicalDevice, pProperties);
26026 if (cmd_size > sizeof(local_cmd_data)) {
26027 cmd_data = malloc(cmd_size);
26028 if (!cmd_data)
26029 cmd_size = 0;
26030 }
26031 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceProperties_reply(physicalDevice, pProperties) : 0;
26032
26033 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26034 if (cmd_size) {
26035 vn_encode_vkGetPhysicalDeviceProperties(enc, cmd_flags, physicalDevice, pProperties);
26036 vn_ring_submit_command(vn_ring, submit);
26037 if (cmd_data != local_cmd_data)
26038 free(cmd_data);
26039 }
26040 }
26041
vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties,struct vn_ring_submit_command * submit)26042 static inline void vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties, struct vn_ring_submit_command *submit)
26043 {
26044 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26045 void *cmd_data = local_cmd_data;
26046 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
26047 if (cmd_size > sizeof(local_cmd_data)) {
26048 cmd_data = malloc(cmd_size);
26049 if (!cmd_data)
26050 cmd_size = 0;
26051 }
26052 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) : 0;
26053
26054 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26055 if (cmd_size) {
26056 vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(enc, cmd_flags, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
26057 vn_ring_submit_command(vn_ring, submit);
26058 if (cmd_data != local_cmd_data)
26059 free(cmd_data);
26060 }
26061 }
26062
vn_submit_vkGetPhysicalDeviceMemoryProperties(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties,struct vn_ring_submit_command * submit)26063 static inline void vn_submit_vkGetPhysicalDeviceMemoryProperties(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties, struct vn_ring_submit_command *submit)
26064 {
26065 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26066 void *cmd_data = local_cmd_data;
26067 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
26068 if (cmd_size > sizeof(local_cmd_data)) {
26069 cmd_data = malloc(cmd_size);
26070 if (!cmd_data)
26071 cmd_size = 0;
26072 }
26073 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(physicalDevice, pMemoryProperties) : 0;
26074
26075 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26076 if (cmd_size) {
26077 vn_encode_vkGetPhysicalDeviceMemoryProperties(enc, cmd_flags, physicalDevice, pMemoryProperties);
26078 vn_ring_submit_command(vn_ring, submit);
26079 if (cmd_data != local_cmd_data)
26080 free(cmd_data);
26081 }
26082 }
26083
vn_submit_vkGetPhysicalDeviceFeatures(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures,struct vn_ring_submit_command * submit)26084 static inline void vn_submit_vkGetPhysicalDeviceFeatures(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures, struct vn_ring_submit_command *submit)
26085 {
26086 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26087 void *cmd_data = local_cmd_data;
26088 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
26089 if (cmd_size > sizeof(local_cmd_data)) {
26090 cmd_data = malloc(cmd_size);
26091 if (!cmd_data)
26092 cmd_size = 0;
26093 }
26094 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFeatures_reply(physicalDevice, pFeatures) : 0;
26095
26096 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26097 if (cmd_size) {
26098 vn_encode_vkGetPhysicalDeviceFeatures(enc, cmd_flags, physicalDevice, pFeatures);
26099 vn_ring_submit_command(vn_ring, submit);
26100 if (cmd_data != local_cmd_data)
26101 free(cmd_data);
26102 }
26103 }
26104
vn_submit_vkGetPhysicalDeviceFormatProperties(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties,struct vn_ring_submit_command * submit)26105 static inline void vn_submit_vkGetPhysicalDeviceFormatProperties(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties, struct vn_ring_submit_command *submit)
26106 {
26107 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26108 void *cmd_data = local_cmd_data;
26109 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
26110 if (cmd_size > sizeof(local_cmd_data)) {
26111 cmd_data = malloc(cmd_size);
26112 if (!cmd_data)
26113 cmd_size = 0;
26114 }
26115 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(physicalDevice, format, pFormatProperties) : 0;
26116
26117 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26118 if (cmd_size) {
26119 vn_encode_vkGetPhysicalDeviceFormatProperties(enc, cmd_flags, physicalDevice, format, pFormatProperties);
26120 vn_ring_submit_command(vn_ring, submit);
26121 if (cmd_data != local_cmd_data)
26122 free(cmd_data);
26123 }
26124 }
26125
vn_submit_vkGetPhysicalDeviceImageFormatProperties(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties,struct vn_ring_submit_command * submit)26126 static inline void vn_submit_vkGetPhysicalDeviceImageFormatProperties(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties, struct vn_ring_submit_command *submit)
26127 {
26128 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26129 void *cmd_data = local_cmd_data;
26130 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
26131 if (cmd_size > sizeof(local_cmd_data)) {
26132 cmd_data = malloc(cmd_size);
26133 if (!cmd_data)
26134 cmd_size = 0;
26135 }
26136 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;
26137
26138 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26139 if (cmd_size) {
26140 vn_encode_vkGetPhysicalDeviceImageFormatProperties(enc, cmd_flags, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
26141 vn_ring_submit_command(vn_ring, submit);
26142 if (cmd_data != local_cmd_data)
26143 free(cmd_data);
26144 }
26145 }
26146
vn_submit_vkCreateDevice(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice,struct vn_ring_submit_command * submit)26147 static inline void vn_submit_vkCreateDevice(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, struct vn_ring_submit_command *submit)
26148 {
26149 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26150 void *cmd_data = local_cmd_data;
26151 size_t cmd_size = vn_sizeof_vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
26152 if (cmd_size > sizeof(local_cmd_data)) {
26153 cmd_data = malloc(cmd_size);
26154 if (!cmd_data)
26155 cmd_size = 0;
26156 }
26157 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDevice_reply(physicalDevice, pCreateInfo, pAllocator, pDevice) : 0;
26158
26159 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26160 if (cmd_size) {
26161 vn_encode_vkCreateDevice(enc, cmd_flags, physicalDevice, pCreateInfo, pAllocator, pDevice);
26162 vn_ring_submit_command(vn_ring, submit);
26163 if (cmd_data != local_cmd_data)
26164 free(cmd_data);
26165 }
26166 }
26167
vn_submit_vkDestroyDevice(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkAllocationCallbacks * pAllocator,struct vn_ring_submit_command * submit)26168 static inline void vn_submit_vkDestroyDevice(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkAllocationCallbacks* pAllocator, struct vn_ring_submit_command *submit)
26169 {
26170 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26171 void *cmd_data = local_cmd_data;
26172 size_t cmd_size = vn_sizeof_vkDestroyDevice(device, pAllocator);
26173 if (cmd_size > sizeof(local_cmd_data)) {
26174 cmd_data = malloc(cmd_size);
26175 if (!cmd_data)
26176 cmd_size = 0;
26177 }
26178 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDevice_reply(device, pAllocator) : 0;
26179
26180 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26181 if (cmd_size) {
26182 vn_encode_vkDestroyDevice(enc, cmd_flags, device, pAllocator);
26183 vn_ring_submit_command(vn_ring, submit);
26184 if (cmd_data != local_cmd_data)
26185 free(cmd_data);
26186 }
26187 }
26188
vn_submit_vkEnumerateDeviceLayerProperties(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties,struct vn_ring_submit_command * submit)26189 static inline void vn_submit_vkEnumerateDeviceLayerProperties(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties, struct vn_ring_submit_command *submit)
26190 {
26191 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26192 void *cmd_data = local_cmd_data;
26193 size_t cmd_size = vn_sizeof_vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
26194 if (cmd_size > sizeof(local_cmd_data)) {
26195 cmd_data = malloc(cmd_size);
26196 if (!cmd_data)
26197 cmd_size = 0;
26198 }
26199 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateDeviceLayerProperties_reply(physicalDevice, pPropertyCount, pProperties) : 0;
26200
26201 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26202 if (cmd_size) {
26203 vn_encode_vkEnumerateDeviceLayerProperties(enc, cmd_flags, physicalDevice, pPropertyCount, pProperties);
26204 vn_ring_submit_command(vn_ring, submit);
26205 if (cmd_data != local_cmd_data)
26206 free(cmd_data);
26207 }
26208 }
26209
vn_submit_vkEnumerateDeviceExtensionProperties(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties,struct vn_ring_submit_command * submit)26210 static inline void vn_submit_vkEnumerateDeviceExtensionProperties(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, struct vn_ring_submit_command *submit)
26211 {
26212 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26213 void *cmd_data = local_cmd_data;
26214 size_t cmd_size = vn_sizeof_vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
26215 if (cmd_size > sizeof(local_cmd_data)) {
26216 cmd_data = malloc(cmd_size);
26217 if (!cmd_data)
26218 cmd_size = 0;
26219 }
26220 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(physicalDevice, pLayerName, pPropertyCount, pProperties) : 0;
26221
26222 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26223 if (cmd_size) {
26224 vn_encode_vkEnumerateDeviceExtensionProperties(enc, cmd_flags, physicalDevice, pLayerName, pPropertyCount, pProperties);
26225 vn_ring_submit_command(vn_ring, submit);
26226 if (cmd_data != local_cmd_data)
26227 free(cmd_data);
26228 }
26229 }
26230
vn_submit_vkGetDeviceQueue(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue,struct vn_ring_submit_command * submit)26231 static inline void vn_submit_vkGetDeviceQueue(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue, struct vn_ring_submit_command *submit)
26232 {
26233 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26234 void *cmd_data = local_cmd_data;
26235 size_t cmd_size = vn_sizeof_vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
26236 if (cmd_size > sizeof(local_cmd_data)) {
26237 cmd_data = malloc(cmd_size);
26238 if (!cmd_data)
26239 cmd_size = 0;
26240 }
26241 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceQueue_reply(device, queueFamilyIndex, queueIndex, pQueue) : 0;
26242
26243 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26244 if (cmd_size) {
26245 vn_encode_vkGetDeviceQueue(enc, cmd_flags, device, queueFamilyIndex, queueIndex, pQueue);
26246 vn_ring_submit_command(vn_ring, submit);
26247 if (cmd_data != local_cmd_data)
26248 free(cmd_data);
26249 }
26250 }
26251
vn_submit_vkDeviceWaitIdle(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,struct vn_ring_submit_command * submit)26252 static inline void vn_submit_vkDeviceWaitIdle(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, struct vn_ring_submit_command *submit)
26253 {
26254 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26255 void *cmd_data = local_cmd_data;
26256 size_t cmd_size = vn_sizeof_vkDeviceWaitIdle(device);
26257 if (cmd_size > sizeof(local_cmd_data)) {
26258 cmd_data = malloc(cmd_size);
26259 if (!cmd_data)
26260 cmd_size = 0;
26261 }
26262 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDeviceWaitIdle_reply(device) : 0;
26263
26264 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26265 if (cmd_size) {
26266 vn_encode_vkDeviceWaitIdle(enc, cmd_flags, device);
26267 vn_ring_submit_command(vn_ring, submit);
26268 if (cmd_data != local_cmd_data)
26269 free(cmd_data);
26270 }
26271 }
26272
vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties,struct vn_ring_submit_command * submit)26273 static inline void vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties, struct vn_ring_submit_command *submit)
26274 {
26275 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26276 void *cmd_data = local_cmd_data;
26277 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
26278 if (cmd_size > sizeof(local_cmd_data)) {
26279 cmd_data = malloc(cmd_size);
26280 if (!cmd_data)
26281 cmd_size = 0;
26282 }
26283 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;
26284
26285 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26286 if (cmd_size) {
26287 vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties(enc, cmd_flags, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
26288 vn_ring_submit_command(vn_ring, submit);
26289 if (cmd_data != local_cmd_data)
26290 free(cmd_data);
26291 }
26292 }
26293
vn_submit_vkGetPhysicalDeviceFeatures2(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures,struct vn_ring_submit_command * submit)26294 static inline void vn_submit_vkGetPhysicalDeviceFeatures2(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures, struct vn_ring_submit_command *submit)
26295 {
26296 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26297 void *cmd_data = local_cmd_data;
26298 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
26299 if (cmd_size > sizeof(local_cmd_data)) {
26300 cmd_data = malloc(cmd_size);
26301 if (!cmd_data)
26302 cmd_size = 0;
26303 }
26304 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(physicalDevice, pFeatures) : 0;
26305
26306 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26307 if (cmd_size) {
26308 vn_encode_vkGetPhysicalDeviceFeatures2(enc, cmd_flags, physicalDevice, pFeatures);
26309 vn_ring_submit_command(vn_ring, submit);
26310 if (cmd_data != local_cmd_data)
26311 free(cmd_data);
26312 }
26313 }
26314
vn_submit_vkGetPhysicalDeviceProperties2(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties,struct vn_ring_submit_command * submit)26315 static inline void vn_submit_vkGetPhysicalDeviceProperties2(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties, struct vn_ring_submit_command *submit)
26316 {
26317 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26318 void *cmd_data = local_cmd_data;
26319 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceProperties2(physicalDevice, pProperties);
26320 if (cmd_size > sizeof(local_cmd_data)) {
26321 cmd_data = malloc(cmd_size);
26322 if (!cmd_data)
26323 cmd_size = 0;
26324 }
26325 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceProperties2_reply(physicalDevice, pProperties) : 0;
26326
26327 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26328 if (cmd_size) {
26329 vn_encode_vkGetPhysicalDeviceProperties2(enc, cmd_flags, physicalDevice, pProperties);
26330 vn_ring_submit_command(vn_ring, submit);
26331 if (cmd_data != local_cmd_data)
26332 free(cmd_data);
26333 }
26334 }
26335
vn_submit_vkGetPhysicalDeviceFormatProperties2(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties,struct vn_ring_submit_command * submit)26336 static inline void vn_submit_vkGetPhysicalDeviceFormatProperties2(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties, struct vn_ring_submit_command *submit)
26337 {
26338 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26339 void *cmd_data = local_cmd_data;
26340 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
26341 if (cmd_size > sizeof(local_cmd_data)) {
26342 cmd_data = malloc(cmd_size);
26343 if (!cmd_data)
26344 cmd_size = 0;
26345 }
26346 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(physicalDevice, format, pFormatProperties) : 0;
26347
26348 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26349 if (cmd_size) {
26350 vn_encode_vkGetPhysicalDeviceFormatProperties2(enc, cmd_flags, physicalDevice, format, pFormatProperties);
26351 vn_ring_submit_command(vn_ring, submit);
26352 if (cmd_data != local_cmd_data)
26353 free(cmd_data);
26354 }
26355 }
26356
vn_submit_vkGetPhysicalDeviceImageFormatProperties2(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties,struct vn_ring_submit_command * submit)26357 static inline void vn_submit_vkGetPhysicalDeviceImageFormatProperties2(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties, struct vn_ring_submit_command *submit)
26358 {
26359 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26360 void *cmd_data = local_cmd_data;
26361 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties);
26362 if (cmd_size > sizeof(local_cmd_data)) {
26363 cmd_data = malloc(cmd_size);
26364 if (!cmd_data)
26365 cmd_size = 0;
26366 }
26367 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(physicalDevice, pImageFormatInfo, pImageFormatProperties) : 0;
26368
26369 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26370 if (cmd_size) {
26371 vn_encode_vkGetPhysicalDeviceImageFormatProperties2(enc, cmd_flags, physicalDevice, pImageFormatInfo, pImageFormatProperties);
26372 vn_ring_submit_command(vn_ring, submit);
26373 if (cmd_data != local_cmd_data)
26374 free(cmd_data);
26375 }
26376 }
26377
vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties,struct vn_ring_submit_command * submit)26378 static inline void vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties, struct vn_ring_submit_command *submit)
26379 {
26380 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26381 void *cmd_data = local_cmd_data;
26382 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
26383 if (cmd_size > sizeof(local_cmd_data)) {
26384 cmd_data = malloc(cmd_size);
26385 if (!cmd_data)
26386 cmd_size = 0;
26387 }
26388 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) : 0;
26389
26390 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26391 if (cmd_size) {
26392 vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(enc, cmd_flags, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
26393 vn_ring_submit_command(vn_ring, submit);
26394 if (cmd_data != local_cmd_data)
26395 free(cmd_data);
26396 }
26397 }
26398
vn_submit_vkGetPhysicalDeviceMemoryProperties2(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties,struct vn_ring_submit_command * submit)26399 static inline void vn_submit_vkGetPhysicalDeviceMemoryProperties2(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties, struct vn_ring_submit_command *submit)
26400 {
26401 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26402 void *cmd_data = local_cmd_data;
26403 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
26404 if (cmd_size > sizeof(local_cmd_data)) {
26405 cmd_data = malloc(cmd_size);
26406 if (!cmd_data)
26407 cmd_size = 0;
26408 }
26409 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(physicalDevice, pMemoryProperties) : 0;
26410
26411 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26412 if (cmd_size) {
26413 vn_encode_vkGetPhysicalDeviceMemoryProperties2(enc, cmd_flags, physicalDevice, pMemoryProperties);
26414 vn_ring_submit_command(vn_ring, submit);
26415 if (cmd_data != local_cmd_data)
26416 free(cmd_data);
26417 }
26418 }
26419
vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties,struct vn_ring_submit_command * submit)26420 static inline void vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties, struct vn_ring_submit_command *submit)
26421 {
26422 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26423 void *cmd_data = local_cmd_data;
26424 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
26425 if (cmd_size > sizeof(local_cmd_data)) {
26426 cmd_data = malloc(cmd_size);
26427 if (!cmd_data)
26428 cmd_size = 0;
26429 }
26430 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(physicalDevice, pFormatInfo, pPropertyCount, pProperties) : 0;
26431
26432 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26433 if (cmd_size) {
26434 vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(enc, cmd_flags, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
26435 vn_ring_submit_command(vn_ring, submit);
26436 if (cmd_data != local_cmd_data)
26437 free(cmd_data);
26438 }
26439 }
26440
vn_submit_vkGetPhysicalDeviceExternalBufferProperties(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties,struct vn_ring_submit_command * submit)26441 static inline void vn_submit_vkGetPhysicalDeviceExternalBufferProperties(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties, struct vn_ring_submit_command *submit)
26442 {
26443 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26444 void *cmd_data = local_cmd_data;
26445 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
26446 if (cmd_size > sizeof(local_cmd_data)) {
26447 cmd_data = malloc(cmd_size);
26448 if (!cmd_data)
26449 cmd_size = 0;
26450 }
26451 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(physicalDevice, pExternalBufferInfo, pExternalBufferProperties) : 0;
26452
26453 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26454 if (cmd_size) {
26455 vn_encode_vkGetPhysicalDeviceExternalBufferProperties(enc, cmd_flags, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
26456 vn_ring_submit_command(vn_ring, submit);
26457 if (cmd_data != local_cmd_data)
26458 free(cmd_data);
26459 }
26460 }
26461
vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties,struct vn_ring_submit_command * submit)26462 static inline void vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties, struct vn_ring_submit_command *submit)
26463 {
26464 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26465 void *cmd_data = local_cmd_data;
26466 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
26467 if (cmd_size > sizeof(local_cmd_data)) {
26468 cmd_data = malloc(cmd_size);
26469 if (!cmd_data)
26470 cmd_size = 0;
26471 }
26472 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties) : 0;
26473
26474 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26475 if (cmd_size) {
26476 vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(enc, cmd_flags, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
26477 vn_ring_submit_command(vn_ring, submit);
26478 if (cmd_data != local_cmd_data)
26479 free(cmd_data);
26480 }
26481 }
26482
vn_submit_vkGetPhysicalDeviceExternalFenceProperties(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties,struct vn_ring_submit_command * submit)26483 static inline void vn_submit_vkGetPhysicalDeviceExternalFenceProperties(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties, struct vn_ring_submit_command *submit)
26484 {
26485 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26486 void *cmd_data = local_cmd_data;
26487 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
26488 if (cmd_size > sizeof(local_cmd_data)) {
26489 cmd_data = malloc(cmd_size);
26490 if (!cmd_data)
26491 cmd_size = 0;
26492 }
26493 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(physicalDevice, pExternalFenceInfo, pExternalFenceProperties) : 0;
26494
26495 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26496 if (cmd_size) {
26497 vn_encode_vkGetPhysicalDeviceExternalFenceProperties(enc, cmd_flags, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
26498 vn_ring_submit_command(vn_ring, submit);
26499 if (cmd_data != local_cmd_data)
26500 free(cmd_data);
26501 }
26502 }
26503
vn_submit_vkEnumeratePhysicalDeviceGroups(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,struct vn_ring_submit_command * submit)26504 static inline void vn_submit_vkEnumeratePhysicalDeviceGroups(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, struct vn_ring_submit_command *submit)
26505 {
26506 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26507 void *cmd_data = local_cmd_data;
26508 size_t cmd_size = vn_sizeof_vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
26509 if (cmd_size > sizeof(local_cmd_data)) {
26510 cmd_data = malloc(cmd_size);
26511 if (!cmd_data)
26512 cmd_size = 0;
26513 }
26514 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties) : 0;
26515
26516 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26517 if (cmd_size) {
26518 vn_encode_vkEnumeratePhysicalDeviceGroups(enc, cmd_flags, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
26519 vn_ring_submit_command(vn_ring, submit);
26520 if (cmd_data != local_cmd_data)
26521 free(cmd_data);
26522 }
26523 }
26524
vn_submit_vkGetDeviceGroupPeerMemoryFeatures(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures,struct vn_ring_submit_command * submit)26525 static inline void vn_submit_vkGetDeviceGroupPeerMemoryFeatures(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures, struct vn_ring_submit_command *submit)
26526 {
26527 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26528 void *cmd_data = local_cmd_data;
26529 size_t cmd_size = vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
26530 if (cmd_size > sizeof(local_cmd_data)) {
26531 cmd_data = malloc(cmd_size);
26532 if (!cmd_data)
26533 cmd_size = 0;
26534 }
26535 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures) : 0;
26536
26537 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26538 if (cmd_size) {
26539 vn_encode_vkGetDeviceGroupPeerMemoryFeatures(enc, cmd_flags, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
26540 vn_ring_submit_command(vn_ring, submit);
26541 if (cmd_data != local_cmd_data)
26542 free(cmd_data);
26543 }
26544 }
26545
vn_submit_vkGetDeviceQueue2(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue,struct vn_ring_submit_command * submit)26546 static inline void vn_submit_vkGetDeviceQueue2(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue, struct vn_ring_submit_command *submit)
26547 {
26548 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26549 void *cmd_data = local_cmd_data;
26550 size_t cmd_size = vn_sizeof_vkGetDeviceQueue2(device, pQueueInfo, pQueue);
26551 if (cmd_size > sizeof(local_cmd_data)) {
26552 cmd_data = malloc(cmd_size);
26553 if (!cmd_data)
26554 cmd_size = 0;
26555 }
26556 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceQueue2_reply(device, pQueueInfo, pQueue) : 0;
26557
26558 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26559 if (cmd_size) {
26560 vn_encode_vkGetDeviceQueue2(enc, cmd_flags, device, pQueueInfo, pQueue);
26561 vn_ring_submit_command(vn_ring, submit);
26562 if (cmd_data != local_cmd_data)
26563 free(cmd_data);
26564 }
26565 }
26566
vn_submit_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pTimeDomainCount,VkTimeDomainEXT * pTimeDomains,struct vn_ring_submit_command * submit)26567 static inline void vn_submit_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains, struct vn_ring_submit_command *submit)
26568 {
26569 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26570 void *cmd_data = local_cmd_data;
26571 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains);
26572 if (cmd_size > sizeof(local_cmd_data)) {
26573 cmd_data = malloc(cmd_size);
26574 if (!cmd_data)
26575 cmd_size = 0;
26576 }
26577 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_reply(physicalDevice, pTimeDomainCount, pTimeDomains) : 0;
26578
26579 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26580 if (cmd_size) {
26581 vn_encode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(enc, cmd_flags, physicalDevice, pTimeDomainCount, pTimeDomains);
26582 vn_ring_submit_command(vn_ring, submit);
26583 if (cmd_data != local_cmd_data)
26584 free(cmd_data);
26585 }
26586 }
26587
vn_submit_vkGetCalibratedTimestampsEXT(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t timestampCount,const VkCalibratedTimestampInfoEXT * pTimestampInfos,uint64_t * pTimestamps,uint64_t * pMaxDeviation,struct vn_ring_submit_command * submit)26588 static inline void vn_submit_vkGetCalibratedTimestampsEXT(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, struct vn_ring_submit_command *submit)
26589 {
26590 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26591 void *cmd_data = local_cmd_data;
26592 size_t cmd_size = vn_sizeof_vkGetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
26593 if (cmd_size > sizeof(local_cmd_data)) {
26594 cmd_data = malloc(cmd_size);
26595 if (!cmd_data)
26596 cmd_size = 0;
26597 }
26598 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetCalibratedTimestampsEXT_reply(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation) : 0;
26599
26600 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26601 if (cmd_size) {
26602 vn_encode_vkGetCalibratedTimestampsEXT(enc, cmd_flags, device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
26603 vn_ring_submit_command(vn_ring, submit);
26604 if (cmd_data != local_cmd_data)
26605 free(cmd_data);
26606 }
26607 }
26608
vn_submit_vkGetPhysicalDeviceToolProperties(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pToolCount,VkPhysicalDeviceToolProperties * pToolProperties,struct vn_ring_submit_command * submit)26609 static inline void vn_submit_vkGetPhysicalDeviceToolProperties(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties, struct vn_ring_submit_command *submit)
26610 {
26611 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26612 void *cmd_data = local_cmd_data;
26613 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties);
26614 if (cmd_size > sizeof(local_cmd_data)) {
26615 cmd_data = malloc(cmd_size);
26616 if (!cmd_data)
26617 cmd_size = 0;
26618 }
26619 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceToolProperties_reply(physicalDevice, pToolCount, pToolProperties) : 0;
26620
26621 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26622 if (cmd_size) {
26623 vn_encode_vkGetPhysicalDeviceToolProperties(enc, cmd_flags, physicalDevice, pToolCount, pToolProperties);
26624 vn_ring_submit_command(vn_ring, submit);
26625 if (cmd_data != local_cmd_data)
26626 free(cmd_data);
26627 }
26628 }
26629
vn_submit_vkGetPhysicalDeviceFragmentShadingRatesKHR(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pFragmentShadingRateCount,VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates,struct vn_ring_submit_command * submit)26630 static inline void vn_submit_vkGetPhysicalDeviceFragmentShadingRatesKHR(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates, struct vn_ring_submit_command *submit)
26631 {
26632 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
26633 void *cmd_data = local_cmd_data;
26634 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
26635 if (cmd_size > sizeof(local_cmd_data)) {
26636 cmd_data = malloc(cmd_size);
26637 if (!cmd_data)
26638 cmd_size = 0;
26639 }
26640 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFragmentShadingRatesKHR_reply(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates) : 0;
26641
26642 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
26643 if (cmd_size) {
26644 vn_encode_vkGetPhysicalDeviceFragmentShadingRatesKHR(enc, cmd_flags, physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
26645 vn_ring_submit_command(vn_ring, submit);
26646 if (cmd_data != local_cmd_data)
26647 free(cmd_data);
26648 }
26649 }
26650
vn_call_vkEnumeratePhysicalDevices(struct vn_ring * vn_ring,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)26651 static inline VkResult vn_call_vkEnumeratePhysicalDevices(struct vn_ring *vn_ring, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
26652 {
26653 VN_TRACE_FUNC();
26654
26655 struct vn_ring_submit_command submit;
26656 vn_submit_vkEnumeratePhysicalDevices(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pPhysicalDeviceCount, pPhysicalDevices, &submit);
26657 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
26658 if (dec) {
26659 const VkResult ret = vn_decode_vkEnumeratePhysicalDevices_reply(dec, instance, pPhysicalDeviceCount, pPhysicalDevices);
26660 vn_ring_free_command_reply(vn_ring, &submit);
26661 return ret;
26662 } else {
26663 return VK_ERROR_OUT_OF_HOST_MEMORY;
26664 }
26665 }
26666
vn_async_vkEnumeratePhysicalDevices(struct vn_ring * vn_ring,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)26667 static inline void vn_async_vkEnumeratePhysicalDevices(struct vn_ring *vn_ring, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
26668 {
26669 struct vn_ring_submit_command submit;
26670 vn_submit_vkEnumeratePhysicalDevices(vn_ring, 0, instance, pPhysicalDeviceCount, pPhysicalDevices, &submit);
26671 }
26672
vn_call_vkGetPhysicalDeviceProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)26673 static inline void vn_call_vkGetPhysicalDeviceProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
26674 {
26675 VN_TRACE_FUNC();
26676
26677 struct vn_ring_submit_command submit;
26678 vn_submit_vkGetPhysicalDeviceProperties(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pProperties, &submit);
26679 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
26680 if (dec) {
26681 vn_decode_vkGetPhysicalDeviceProperties_reply(dec, physicalDevice, pProperties);
26682 vn_ring_free_command_reply(vn_ring, &submit);
26683 }
26684 }
26685
vn_async_vkGetPhysicalDeviceProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)26686 static inline void vn_async_vkGetPhysicalDeviceProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
26687 {
26688 struct vn_ring_submit_command submit;
26689 vn_submit_vkGetPhysicalDeviceProperties(vn_ring, 0, physicalDevice, pProperties, &submit);
26690 }
26691
vn_call_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)26692 static inline void vn_call_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
26693 {
26694 VN_TRACE_FUNC();
26695
26696 struct vn_ring_submit_command submit;
26697 vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
26698 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
26699 if (dec) {
26700 vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(dec, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
26701 vn_ring_free_command_reply(vn_ring, &submit);
26702 }
26703 }
26704
vn_async_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)26705 static inline void vn_async_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
26706 {
26707 struct vn_ring_submit_command submit;
26708 vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(vn_ring, 0, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
26709 }
26710
vn_call_vkGetPhysicalDeviceMemoryProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)26711 static inline void vn_call_vkGetPhysicalDeviceMemoryProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
26712 {
26713 VN_TRACE_FUNC();
26714
26715 struct vn_ring_submit_command submit;
26716 vn_submit_vkGetPhysicalDeviceMemoryProperties(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pMemoryProperties, &submit);
26717 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
26718 if (dec) {
26719 vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(dec, physicalDevice, pMemoryProperties);
26720 vn_ring_free_command_reply(vn_ring, &submit);
26721 }
26722 }
26723
vn_async_vkGetPhysicalDeviceMemoryProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)26724 static inline void vn_async_vkGetPhysicalDeviceMemoryProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
26725 {
26726 struct vn_ring_submit_command submit;
26727 vn_submit_vkGetPhysicalDeviceMemoryProperties(vn_ring, 0, physicalDevice, pMemoryProperties, &submit);
26728 }
26729
vn_call_vkGetPhysicalDeviceFeatures(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)26730 static inline void vn_call_vkGetPhysicalDeviceFeatures(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
26731 {
26732 VN_TRACE_FUNC();
26733
26734 struct vn_ring_submit_command submit;
26735 vn_submit_vkGetPhysicalDeviceFeatures(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFeatures, &submit);
26736 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
26737 if (dec) {
26738 vn_decode_vkGetPhysicalDeviceFeatures_reply(dec, physicalDevice, pFeatures);
26739 vn_ring_free_command_reply(vn_ring, &submit);
26740 }
26741 }
26742
vn_async_vkGetPhysicalDeviceFeatures(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)26743 static inline void vn_async_vkGetPhysicalDeviceFeatures(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
26744 {
26745 struct vn_ring_submit_command submit;
26746 vn_submit_vkGetPhysicalDeviceFeatures(vn_ring, 0, physicalDevice, pFeatures, &submit);
26747 }
26748
vn_call_vkGetPhysicalDeviceFormatProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)26749 static inline void vn_call_vkGetPhysicalDeviceFormatProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
26750 {
26751 VN_TRACE_FUNC();
26752
26753 struct vn_ring_submit_command submit;
26754 vn_submit_vkGetPhysicalDeviceFormatProperties(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, pFormatProperties, &submit);
26755 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
26756 if (dec) {
26757 vn_decode_vkGetPhysicalDeviceFormatProperties_reply(dec, physicalDevice, format, pFormatProperties);
26758 vn_ring_free_command_reply(vn_ring, &submit);
26759 }
26760 }
26761
vn_async_vkGetPhysicalDeviceFormatProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)26762 static inline void vn_async_vkGetPhysicalDeviceFormatProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
26763 {
26764 struct vn_ring_submit_command submit;
26765 vn_submit_vkGetPhysicalDeviceFormatProperties(vn_ring, 0, physicalDevice, format, pFormatProperties, &submit);
26766 }
26767
vn_call_vkGetPhysicalDeviceImageFormatProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)26768 static inline VkResult vn_call_vkGetPhysicalDeviceImageFormatProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
26769 {
26770 VN_TRACE_FUNC();
26771
26772 struct vn_ring_submit_command submit;
26773 vn_submit_vkGetPhysicalDeviceImageFormatProperties(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, &submit);
26774 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
26775 if (dec) {
26776 const VkResult ret = vn_decode_vkGetPhysicalDeviceImageFormatProperties_reply(dec, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
26777 vn_ring_free_command_reply(vn_ring, &submit);
26778 return ret;
26779 } else {
26780 return VK_ERROR_OUT_OF_HOST_MEMORY;
26781 }
26782 }
26783
vn_async_vkGetPhysicalDeviceImageFormatProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)26784 static inline void vn_async_vkGetPhysicalDeviceImageFormatProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
26785 {
26786 struct vn_ring_submit_command submit;
26787 vn_submit_vkGetPhysicalDeviceImageFormatProperties(vn_ring, 0, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, &submit);
26788 }
26789
vn_call_vkCreateDevice(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)26790 static inline VkResult vn_call_vkCreateDevice(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
26791 {
26792 VN_TRACE_FUNC();
26793
26794 struct vn_ring_submit_command submit;
26795 vn_submit_vkCreateDevice(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pCreateInfo, pAllocator, pDevice, &submit);
26796 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
26797 if (dec) {
26798 const VkResult ret = vn_decode_vkCreateDevice_reply(dec, physicalDevice, pCreateInfo, pAllocator, pDevice);
26799 vn_ring_free_command_reply(vn_ring, &submit);
26800 return ret;
26801 } else {
26802 return VK_ERROR_OUT_OF_HOST_MEMORY;
26803 }
26804 }
26805
vn_async_vkCreateDevice(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)26806 static inline void vn_async_vkCreateDevice(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
26807 {
26808 struct vn_ring_submit_command submit;
26809 vn_submit_vkCreateDevice(vn_ring, 0, physicalDevice, pCreateInfo, pAllocator, pDevice, &submit);
26810 }
26811
vn_call_vkDestroyDevice(struct vn_ring * vn_ring,VkDevice device,const VkAllocationCallbacks * pAllocator)26812 static inline void vn_call_vkDestroyDevice(struct vn_ring *vn_ring, VkDevice device, const VkAllocationCallbacks* pAllocator)
26813 {
26814 VN_TRACE_FUNC();
26815
26816 struct vn_ring_submit_command submit;
26817 vn_submit_vkDestroyDevice(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocator, &submit);
26818 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
26819 if (dec) {
26820 vn_decode_vkDestroyDevice_reply(dec, device, pAllocator);
26821 vn_ring_free_command_reply(vn_ring, &submit);
26822 }
26823 }
26824
vn_async_vkDestroyDevice(struct vn_ring * vn_ring,VkDevice device,const VkAllocationCallbacks * pAllocator)26825 static inline void vn_async_vkDestroyDevice(struct vn_ring *vn_ring, VkDevice device, const VkAllocationCallbacks* pAllocator)
26826 {
26827 struct vn_ring_submit_command submit;
26828 vn_submit_vkDestroyDevice(vn_ring, 0, device, pAllocator, &submit);
26829 }
26830
vn_call_vkEnumerateDeviceLayerProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)26831 static inline VkResult vn_call_vkEnumerateDeviceLayerProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
26832 {
26833 VN_TRACE_FUNC();
26834
26835 struct vn_ring_submit_command submit;
26836 vn_submit_vkEnumerateDeviceLayerProperties(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pPropertyCount, pProperties, &submit);
26837 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
26838 if (dec) {
26839 const VkResult ret = vn_decode_vkEnumerateDeviceLayerProperties_reply(dec, physicalDevice, pPropertyCount, pProperties);
26840 vn_ring_free_command_reply(vn_ring, &submit);
26841 return ret;
26842 } else {
26843 return VK_ERROR_OUT_OF_HOST_MEMORY;
26844 }
26845 }
26846
vn_async_vkEnumerateDeviceLayerProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)26847 static inline void vn_async_vkEnumerateDeviceLayerProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
26848 {
26849 struct vn_ring_submit_command submit;
26850 vn_submit_vkEnumerateDeviceLayerProperties(vn_ring, 0, physicalDevice, pPropertyCount, pProperties, &submit);
26851 }
26852
vn_call_vkEnumerateDeviceExtensionProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)26853 static inline VkResult vn_call_vkEnumerateDeviceExtensionProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
26854 {
26855 VN_TRACE_FUNC();
26856
26857 struct vn_ring_submit_command submit;
26858 vn_submit_vkEnumerateDeviceExtensionProperties(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pLayerName, pPropertyCount, pProperties, &submit);
26859 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
26860 if (dec) {
26861 const VkResult ret = vn_decode_vkEnumerateDeviceExtensionProperties_reply(dec, physicalDevice, pLayerName, pPropertyCount, pProperties);
26862 vn_ring_free_command_reply(vn_ring, &submit);
26863 return ret;
26864 } else {
26865 return VK_ERROR_OUT_OF_HOST_MEMORY;
26866 }
26867 }
26868
vn_async_vkEnumerateDeviceExtensionProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)26869 static inline void vn_async_vkEnumerateDeviceExtensionProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
26870 {
26871 struct vn_ring_submit_command submit;
26872 vn_submit_vkEnumerateDeviceExtensionProperties(vn_ring, 0, physicalDevice, pLayerName, pPropertyCount, pProperties, &submit);
26873 }
26874
vn_call_vkGetDeviceQueue(struct vn_ring * vn_ring,VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)26875 static inline void vn_call_vkGetDeviceQueue(struct vn_ring *vn_ring, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
26876 {
26877 VN_TRACE_FUNC();
26878
26879 struct vn_ring_submit_command submit;
26880 vn_submit_vkGetDeviceQueue(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queueFamilyIndex, queueIndex, pQueue, &submit);
26881 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
26882 if (dec) {
26883 vn_decode_vkGetDeviceQueue_reply(dec, device, queueFamilyIndex, queueIndex, pQueue);
26884 vn_ring_free_command_reply(vn_ring, &submit);
26885 }
26886 }
26887
vn_async_vkGetDeviceQueue(struct vn_ring * vn_ring,VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)26888 static inline void vn_async_vkGetDeviceQueue(struct vn_ring *vn_ring, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
26889 {
26890 struct vn_ring_submit_command submit;
26891 vn_submit_vkGetDeviceQueue(vn_ring, 0, device, queueFamilyIndex, queueIndex, pQueue, &submit);
26892 }
26893
vn_call_vkDeviceWaitIdle(struct vn_ring * vn_ring,VkDevice device)26894 static inline VkResult vn_call_vkDeviceWaitIdle(struct vn_ring *vn_ring, VkDevice device)
26895 {
26896 VN_TRACE_FUNC();
26897
26898 struct vn_ring_submit_command submit;
26899 vn_submit_vkDeviceWaitIdle(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, &submit);
26900 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
26901 if (dec) {
26902 const VkResult ret = vn_decode_vkDeviceWaitIdle_reply(dec, device);
26903 vn_ring_free_command_reply(vn_ring, &submit);
26904 return ret;
26905 } else {
26906 return VK_ERROR_OUT_OF_HOST_MEMORY;
26907 }
26908 }
26909
vn_async_vkDeviceWaitIdle(struct vn_ring * vn_ring,VkDevice device)26910 static inline void vn_async_vkDeviceWaitIdle(struct vn_ring *vn_ring, VkDevice device)
26911 {
26912 struct vn_ring_submit_command submit;
26913 vn_submit_vkDeviceWaitIdle(vn_ring, 0, device, &submit);
26914 }
26915
vn_call_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)26916 static inline void vn_call_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
26917 {
26918 VN_TRACE_FUNC();
26919
26920 struct vn_ring_submit_command submit;
26921 vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties, &submit);
26922 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
26923 if (dec) {
26924 vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties_reply(dec, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
26925 vn_ring_free_command_reply(vn_ring, &submit);
26926 }
26927 }
26928
vn_async_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)26929 static inline void vn_async_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
26930 {
26931 struct vn_ring_submit_command submit;
26932 vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(vn_ring, 0, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties, &submit);
26933 }
26934
vn_call_vkGetPhysicalDeviceFeatures2(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)26935 static inline void vn_call_vkGetPhysicalDeviceFeatures2(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
26936 {
26937 VN_TRACE_FUNC();
26938
26939 struct vn_ring_submit_command submit;
26940 vn_submit_vkGetPhysicalDeviceFeatures2(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFeatures, &submit);
26941 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
26942 if (dec) {
26943 vn_decode_vkGetPhysicalDeviceFeatures2_reply(dec, physicalDevice, pFeatures);
26944 vn_ring_free_command_reply(vn_ring, &submit);
26945 }
26946 }
26947
vn_async_vkGetPhysicalDeviceFeatures2(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)26948 static inline void vn_async_vkGetPhysicalDeviceFeatures2(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
26949 {
26950 struct vn_ring_submit_command submit;
26951 vn_submit_vkGetPhysicalDeviceFeatures2(vn_ring, 0, physicalDevice, pFeatures, &submit);
26952 }
26953
vn_call_vkGetPhysicalDeviceProperties2(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)26954 static inline void vn_call_vkGetPhysicalDeviceProperties2(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
26955 {
26956 VN_TRACE_FUNC();
26957
26958 struct vn_ring_submit_command submit;
26959 vn_submit_vkGetPhysicalDeviceProperties2(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pProperties, &submit);
26960 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
26961 if (dec) {
26962 vn_decode_vkGetPhysicalDeviceProperties2_reply(dec, physicalDevice, pProperties);
26963 vn_ring_free_command_reply(vn_ring, &submit);
26964 }
26965 }
26966
vn_async_vkGetPhysicalDeviceProperties2(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)26967 static inline void vn_async_vkGetPhysicalDeviceProperties2(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
26968 {
26969 struct vn_ring_submit_command submit;
26970 vn_submit_vkGetPhysicalDeviceProperties2(vn_ring, 0, physicalDevice, pProperties, &submit);
26971 }
26972
vn_call_vkGetPhysicalDeviceFormatProperties2(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)26973 static inline void vn_call_vkGetPhysicalDeviceFormatProperties2(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
26974 {
26975 VN_TRACE_FUNC();
26976
26977 struct vn_ring_submit_command submit;
26978 vn_submit_vkGetPhysicalDeviceFormatProperties2(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, pFormatProperties, &submit);
26979 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
26980 if (dec) {
26981 vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(dec, physicalDevice, format, pFormatProperties);
26982 vn_ring_free_command_reply(vn_ring, &submit);
26983 }
26984 }
26985
vn_async_vkGetPhysicalDeviceFormatProperties2(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)26986 static inline void vn_async_vkGetPhysicalDeviceFormatProperties2(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
26987 {
26988 struct vn_ring_submit_command submit;
26989 vn_submit_vkGetPhysicalDeviceFormatProperties2(vn_ring, 0, physicalDevice, format, pFormatProperties, &submit);
26990 }
26991
vn_call_vkGetPhysicalDeviceImageFormatProperties2(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)26992 static inline VkResult vn_call_vkGetPhysicalDeviceImageFormatProperties2(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
26993 {
26994 VN_TRACE_FUNC();
26995
26996 struct vn_ring_submit_command submit;
26997 vn_submit_vkGetPhysicalDeviceImageFormatProperties2(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pImageFormatInfo, pImageFormatProperties, &submit);
26998 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
26999 if (dec) {
27000 const VkResult ret = vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(dec, physicalDevice, pImageFormatInfo, pImageFormatProperties);
27001 vn_ring_free_command_reply(vn_ring, &submit);
27002 return ret;
27003 } else {
27004 return VK_ERROR_OUT_OF_HOST_MEMORY;
27005 }
27006 }
27007
vn_async_vkGetPhysicalDeviceImageFormatProperties2(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)27008 static inline void vn_async_vkGetPhysicalDeviceImageFormatProperties2(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
27009 {
27010 struct vn_ring_submit_command submit;
27011 vn_submit_vkGetPhysicalDeviceImageFormatProperties2(vn_ring, 0, physicalDevice, pImageFormatInfo, pImageFormatProperties, &submit);
27012 }
27013
vn_call_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)27014 static inline void vn_call_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
27015 {
27016 VN_TRACE_FUNC();
27017
27018 struct vn_ring_submit_command submit;
27019 vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
27020 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
27021 if (dec) {
27022 vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(dec, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
27023 vn_ring_free_command_reply(vn_ring, &submit);
27024 }
27025 }
27026
vn_async_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)27027 static inline void vn_async_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
27028 {
27029 struct vn_ring_submit_command submit;
27030 vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(vn_ring, 0, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
27031 }
27032
vn_call_vkGetPhysicalDeviceMemoryProperties2(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)27033 static inline void vn_call_vkGetPhysicalDeviceMemoryProperties2(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
27034 {
27035 VN_TRACE_FUNC();
27036
27037 struct vn_ring_submit_command submit;
27038 vn_submit_vkGetPhysicalDeviceMemoryProperties2(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pMemoryProperties, &submit);
27039 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
27040 if (dec) {
27041 vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(dec, physicalDevice, pMemoryProperties);
27042 vn_ring_free_command_reply(vn_ring, &submit);
27043 }
27044 }
27045
vn_async_vkGetPhysicalDeviceMemoryProperties2(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)27046 static inline void vn_async_vkGetPhysicalDeviceMemoryProperties2(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
27047 {
27048 struct vn_ring_submit_command submit;
27049 vn_submit_vkGetPhysicalDeviceMemoryProperties2(vn_ring, 0, physicalDevice, pMemoryProperties, &submit);
27050 }
27051
vn_call_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)27052 static inline void vn_call_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
27053 {
27054 VN_TRACE_FUNC();
27055
27056 struct vn_ring_submit_command submit;
27057 vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFormatInfo, pPropertyCount, pProperties, &submit);
27058 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
27059 if (dec) {
27060 vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(dec, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
27061 vn_ring_free_command_reply(vn_ring, &submit);
27062 }
27063 }
27064
vn_async_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)27065 static inline void vn_async_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
27066 {
27067 struct vn_ring_submit_command submit;
27068 vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(vn_ring, 0, physicalDevice, pFormatInfo, pPropertyCount, pProperties, &submit);
27069 }
27070
vn_call_vkGetPhysicalDeviceExternalBufferProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)27071 static inline void vn_call_vkGetPhysicalDeviceExternalBufferProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
27072 {
27073 VN_TRACE_FUNC();
27074
27075 struct vn_ring_submit_command submit;
27076 vn_submit_vkGetPhysicalDeviceExternalBufferProperties(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalBufferInfo, pExternalBufferProperties, &submit);
27077 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
27078 if (dec) {
27079 vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(dec, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
27080 vn_ring_free_command_reply(vn_ring, &submit);
27081 }
27082 }
27083
vn_async_vkGetPhysicalDeviceExternalBufferProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)27084 static inline void vn_async_vkGetPhysicalDeviceExternalBufferProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
27085 {
27086 struct vn_ring_submit_command submit;
27087 vn_submit_vkGetPhysicalDeviceExternalBufferProperties(vn_ring, 0, physicalDevice, pExternalBufferInfo, pExternalBufferProperties, &submit);
27088 }
27089
vn_call_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)27090 static inline void vn_call_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
27091 {
27092 VN_TRACE_FUNC();
27093
27094 struct vn_ring_submit_command submit;
27095 vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, &submit);
27096 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
27097 if (dec) {
27098 vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(dec, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
27099 vn_ring_free_command_reply(vn_ring, &submit);
27100 }
27101 }
27102
vn_async_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)27103 static inline void vn_async_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
27104 {
27105 struct vn_ring_submit_command submit;
27106 vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(vn_ring, 0, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, &submit);
27107 }
27108
vn_call_vkGetPhysicalDeviceExternalFenceProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)27109 static inline void vn_call_vkGetPhysicalDeviceExternalFenceProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
27110 {
27111 VN_TRACE_FUNC();
27112
27113 struct vn_ring_submit_command submit;
27114 vn_submit_vkGetPhysicalDeviceExternalFenceProperties(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalFenceInfo, pExternalFenceProperties, &submit);
27115 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
27116 if (dec) {
27117 vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(dec, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
27118 vn_ring_free_command_reply(vn_ring, &submit);
27119 }
27120 }
27121
vn_async_vkGetPhysicalDeviceExternalFenceProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)27122 static inline void vn_async_vkGetPhysicalDeviceExternalFenceProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
27123 {
27124 struct vn_ring_submit_command submit;
27125 vn_submit_vkGetPhysicalDeviceExternalFenceProperties(vn_ring, 0, physicalDevice, pExternalFenceInfo, pExternalFenceProperties, &submit);
27126 }
27127
vn_call_vkEnumeratePhysicalDeviceGroups(struct vn_ring * vn_ring,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)27128 static inline VkResult vn_call_vkEnumeratePhysicalDeviceGroups(struct vn_ring *vn_ring, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
27129 {
27130 VN_TRACE_FUNC();
27131
27132 struct vn_ring_submit_command submit;
27133 vn_submit_vkEnumeratePhysicalDeviceGroups(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, &submit);
27134 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
27135 if (dec) {
27136 const VkResult ret = vn_decode_vkEnumeratePhysicalDeviceGroups_reply(dec, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
27137 vn_ring_free_command_reply(vn_ring, &submit);
27138 return ret;
27139 } else {
27140 return VK_ERROR_OUT_OF_HOST_MEMORY;
27141 }
27142 }
27143
vn_async_vkEnumeratePhysicalDeviceGroups(struct vn_ring * vn_ring,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)27144 static inline void vn_async_vkEnumeratePhysicalDeviceGroups(struct vn_ring *vn_ring, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
27145 {
27146 struct vn_ring_submit_command submit;
27147 vn_submit_vkEnumeratePhysicalDeviceGroups(vn_ring, 0, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, &submit);
27148 }
27149
vn_call_vkGetDeviceGroupPeerMemoryFeatures(struct vn_ring * vn_ring,VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)27150 static inline void vn_call_vkGetDeviceGroupPeerMemoryFeatures(struct vn_ring *vn_ring, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
27151 {
27152 VN_TRACE_FUNC();
27153
27154 struct vn_ring_submit_command submit;
27155 vn_submit_vkGetDeviceGroupPeerMemoryFeatures(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, &submit);
27156 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
27157 if (dec) {
27158 vn_decode_vkGetDeviceGroupPeerMemoryFeatures_reply(dec, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
27159 vn_ring_free_command_reply(vn_ring, &submit);
27160 }
27161 }
27162
vn_async_vkGetDeviceGroupPeerMemoryFeatures(struct vn_ring * vn_ring,VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)27163 static inline void vn_async_vkGetDeviceGroupPeerMemoryFeatures(struct vn_ring *vn_ring, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
27164 {
27165 struct vn_ring_submit_command submit;
27166 vn_submit_vkGetDeviceGroupPeerMemoryFeatures(vn_ring, 0, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, &submit);
27167 }
27168
vn_call_vkGetDeviceQueue2(struct vn_ring * vn_ring,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)27169 static inline void vn_call_vkGetDeviceQueue2(struct vn_ring *vn_ring, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
27170 {
27171 VN_TRACE_FUNC();
27172
27173 struct vn_ring_submit_command submit;
27174 vn_submit_vkGetDeviceQueue2(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pQueueInfo, pQueue, &submit);
27175 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
27176 if (dec) {
27177 vn_decode_vkGetDeviceQueue2_reply(dec, device, pQueueInfo, pQueue);
27178 vn_ring_free_command_reply(vn_ring, &submit);
27179 }
27180 }
27181
vn_async_vkGetDeviceQueue2(struct vn_ring * vn_ring,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)27182 static inline void vn_async_vkGetDeviceQueue2(struct vn_ring *vn_ring, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
27183 {
27184 struct vn_ring_submit_command submit;
27185 vn_submit_vkGetDeviceQueue2(vn_ring, 0, device, pQueueInfo, pQueue, &submit);
27186 }
27187
vn_call_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,uint32_t * pTimeDomainCount,VkTimeDomainEXT * pTimeDomains)27188 static inline VkResult vn_call_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains)
27189 {
27190 VN_TRACE_FUNC();
27191
27192 struct vn_ring_submit_command submit;
27193 vn_submit_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pTimeDomainCount, pTimeDomains, &submit);
27194 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
27195 if (dec) {
27196 const VkResult ret = vn_decode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_reply(dec, physicalDevice, pTimeDomainCount, pTimeDomains);
27197 vn_ring_free_command_reply(vn_ring, &submit);
27198 return ret;
27199 } else {
27200 return VK_ERROR_OUT_OF_HOST_MEMORY;
27201 }
27202 }
27203
vn_async_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,uint32_t * pTimeDomainCount,VkTimeDomainEXT * pTimeDomains)27204 static inline void vn_async_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains)
27205 {
27206 struct vn_ring_submit_command submit;
27207 vn_submit_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(vn_ring, 0, physicalDevice, pTimeDomainCount, pTimeDomains, &submit);
27208 }
27209
vn_call_vkGetCalibratedTimestampsEXT(struct vn_ring * vn_ring,VkDevice device,uint32_t timestampCount,const VkCalibratedTimestampInfoEXT * pTimestampInfos,uint64_t * pTimestamps,uint64_t * pMaxDeviation)27210 static inline VkResult vn_call_vkGetCalibratedTimestampsEXT(struct vn_ring *vn_ring, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation)
27211 {
27212 VN_TRACE_FUNC();
27213
27214 struct vn_ring_submit_command submit;
27215 vn_submit_vkGetCalibratedTimestampsEXT(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation, &submit);
27216 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
27217 if (dec) {
27218 const VkResult ret = vn_decode_vkGetCalibratedTimestampsEXT_reply(dec, device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
27219 vn_ring_free_command_reply(vn_ring, &submit);
27220 return ret;
27221 } else {
27222 return VK_ERROR_OUT_OF_HOST_MEMORY;
27223 }
27224 }
27225
vn_async_vkGetCalibratedTimestampsEXT(struct vn_ring * vn_ring,VkDevice device,uint32_t timestampCount,const VkCalibratedTimestampInfoEXT * pTimestampInfos,uint64_t * pTimestamps,uint64_t * pMaxDeviation)27226 static inline void vn_async_vkGetCalibratedTimestampsEXT(struct vn_ring *vn_ring, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation)
27227 {
27228 struct vn_ring_submit_command submit;
27229 vn_submit_vkGetCalibratedTimestampsEXT(vn_ring, 0, device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation, &submit);
27230 }
27231
vn_call_vkGetPhysicalDeviceToolProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,uint32_t * pToolCount,VkPhysicalDeviceToolProperties * pToolProperties)27232 static inline VkResult vn_call_vkGetPhysicalDeviceToolProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties)
27233 {
27234 VN_TRACE_FUNC();
27235
27236 struct vn_ring_submit_command submit;
27237 vn_submit_vkGetPhysicalDeviceToolProperties(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pToolCount, pToolProperties, &submit);
27238 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
27239 if (dec) {
27240 const VkResult ret = vn_decode_vkGetPhysicalDeviceToolProperties_reply(dec, physicalDevice, pToolCount, pToolProperties);
27241 vn_ring_free_command_reply(vn_ring, &submit);
27242 return ret;
27243 } else {
27244 return VK_ERROR_OUT_OF_HOST_MEMORY;
27245 }
27246 }
27247
vn_async_vkGetPhysicalDeviceToolProperties(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,uint32_t * pToolCount,VkPhysicalDeviceToolProperties * pToolProperties)27248 static inline void vn_async_vkGetPhysicalDeviceToolProperties(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties)
27249 {
27250 struct vn_ring_submit_command submit;
27251 vn_submit_vkGetPhysicalDeviceToolProperties(vn_ring, 0, physicalDevice, pToolCount, pToolProperties, &submit);
27252 }
27253
vn_call_vkGetPhysicalDeviceFragmentShadingRatesKHR(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,uint32_t * pFragmentShadingRateCount,VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates)27254 static inline VkResult vn_call_vkGetPhysicalDeviceFragmentShadingRatesKHR(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates)
27255 {
27256 VN_TRACE_FUNC();
27257
27258 struct vn_ring_submit_command submit;
27259 vn_submit_vkGetPhysicalDeviceFragmentShadingRatesKHR(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates, &submit);
27260 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
27261 if (dec) {
27262 const VkResult ret = vn_decode_vkGetPhysicalDeviceFragmentShadingRatesKHR_reply(dec, physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
27263 vn_ring_free_command_reply(vn_ring, &submit);
27264 return ret;
27265 } else {
27266 return VK_ERROR_OUT_OF_HOST_MEMORY;
27267 }
27268 }
27269
vn_async_vkGetPhysicalDeviceFragmentShadingRatesKHR(struct vn_ring * vn_ring,VkPhysicalDevice physicalDevice,uint32_t * pFragmentShadingRateCount,VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates)27270 static inline void vn_async_vkGetPhysicalDeviceFragmentShadingRatesKHR(struct vn_ring *vn_ring, VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates)
27271 {
27272 struct vn_ring_submit_command submit;
27273 vn_submit_vkGetPhysicalDeviceFragmentShadingRatesKHR(vn_ring, 0, physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates, &submit);
27274 }
27275
27276 #endif /* VN_PROTOCOL_DRIVER_DEVICE_H */
27277