1 /* This file is generated by venus-protocol. See vn_protocol_driver.h. */
2
3 /*
4 * Copyright 2020 Google LLC
5 * SPDX-License-Identifier: MIT
6 */
7
8 #ifndef VN_PROTOCOL_DRIVER_DEVICE_H
9 #define VN_PROTOCOL_DRIVER_DEVICE_H
10
11 #include "vn_instance.h"
12 #include "vn_protocol_driver_structs.h"
13
14 /*
15 * These structs/unions/commands are not included
16 *
17 * vkGetDeviceProcAddr
18 */
19
20 /* struct VkPhysicalDeviceLimits */
21
22 static inline size_t
vn_sizeof_VkPhysicalDeviceLimits(const VkPhysicalDeviceLimits * val)23 vn_sizeof_VkPhysicalDeviceLimits(const VkPhysicalDeviceLimits *val)
24 {
25 size_t size = 0;
26 size += vn_sizeof_uint32_t(&val->maxImageDimension1D);
27 size += vn_sizeof_uint32_t(&val->maxImageDimension2D);
28 size += vn_sizeof_uint32_t(&val->maxImageDimension3D);
29 size += vn_sizeof_uint32_t(&val->maxImageDimensionCube);
30 size += vn_sizeof_uint32_t(&val->maxImageArrayLayers);
31 size += vn_sizeof_uint32_t(&val->maxTexelBufferElements);
32 size += vn_sizeof_uint32_t(&val->maxUniformBufferRange);
33 size += vn_sizeof_uint32_t(&val->maxStorageBufferRange);
34 size += vn_sizeof_uint32_t(&val->maxPushConstantsSize);
35 size += vn_sizeof_uint32_t(&val->maxMemoryAllocationCount);
36 size += vn_sizeof_uint32_t(&val->maxSamplerAllocationCount);
37 size += vn_sizeof_VkDeviceSize(&val->bufferImageGranularity);
38 size += vn_sizeof_VkDeviceSize(&val->sparseAddressSpaceSize);
39 size += vn_sizeof_uint32_t(&val->maxBoundDescriptorSets);
40 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorSamplers);
41 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUniformBuffers);
42 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorStorageBuffers);
43 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorSampledImages);
44 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorStorageImages);
45 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorInputAttachments);
46 size += vn_sizeof_uint32_t(&val->maxPerStageResources);
47 size += vn_sizeof_uint32_t(&val->maxDescriptorSetSamplers);
48 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUniformBuffers);
49 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUniformBuffersDynamic);
50 size += vn_sizeof_uint32_t(&val->maxDescriptorSetStorageBuffers);
51 size += vn_sizeof_uint32_t(&val->maxDescriptorSetStorageBuffersDynamic);
52 size += vn_sizeof_uint32_t(&val->maxDescriptorSetSampledImages);
53 size += vn_sizeof_uint32_t(&val->maxDescriptorSetStorageImages);
54 size += vn_sizeof_uint32_t(&val->maxDescriptorSetInputAttachments);
55 size += vn_sizeof_uint32_t(&val->maxVertexInputAttributes);
56 size += vn_sizeof_uint32_t(&val->maxVertexInputBindings);
57 size += vn_sizeof_uint32_t(&val->maxVertexInputAttributeOffset);
58 size += vn_sizeof_uint32_t(&val->maxVertexInputBindingStride);
59 size += vn_sizeof_uint32_t(&val->maxVertexOutputComponents);
60 size += vn_sizeof_uint32_t(&val->maxTessellationGenerationLevel);
61 size += vn_sizeof_uint32_t(&val->maxTessellationPatchSize);
62 size += vn_sizeof_uint32_t(&val->maxTessellationControlPerVertexInputComponents);
63 size += vn_sizeof_uint32_t(&val->maxTessellationControlPerVertexOutputComponents);
64 size += vn_sizeof_uint32_t(&val->maxTessellationControlPerPatchOutputComponents);
65 size += vn_sizeof_uint32_t(&val->maxTessellationControlTotalOutputComponents);
66 size += vn_sizeof_uint32_t(&val->maxTessellationEvaluationInputComponents);
67 size += vn_sizeof_uint32_t(&val->maxTessellationEvaluationOutputComponents);
68 size += vn_sizeof_uint32_t(&val->maxGeometryShaderInvocations);
69 size += vn_sizeof_uint32_t(&val->maxGeometryInputComponents);
70 size += vn_sizeof_uint32_t(&val->maxGeometryOutputComponents);
71 size += vn_sizeof_uint32_t(&val->maxGeometryOutputVertices);
72 size += vn_sizeof_uint32_t(&val->maxGeometryTotalOutputComponents);
73 size += vn_sizeof_uint32_t(&val->maxFragmentInputComponents);
74 size += vn_sizeof_uint32_t(&val->maxFragmentOutputAttachments);
75 size += vn_sizeof_uint32_t(&val->maxFragmentDualSrcAttachments);
76 size += vn_sizeof_uint32_t(&val->maxFragmentCombinedOutputResources);
77 size += vn_sizeof_uint32_t(&val->maxComputeSharedMemorySize);
78 size += vn_sizeof_array_size(3);
79 size += vn_sizeof_uint32_t_array(val->maxComputeWorkGroupCount, 3);
80 size += vn_sizeof_uint32_t(&val->maxComputeWorkGroupInvocations);
81 size += vn_sizeof_array_size(3);
82 size += vn_sizeof_uint32_t_array(val->maxComputeWorkGroupSize, 3);
83 size += vn_sizeof_uint32_t(&val->subPixelPrecisionBits);
84 size += vn_sizeof_uint32_t(&val->subTexelPrecisionBits);
85 size += vn_sizeof_uint32_t(&val->mipmapPrecisionBits);
86 size += vn_sizeof_uint32_t(&val->maxDrawIndexedIndexValue);
87 size += vn_sizeof_uint32_t(&val->maxDrawIndirectCount);
88 size += vn_sizeof_float(&val->maxSamplerLodBias);
89 size += vn_sizeof_float(&val->maxSamplerAnisotropy);
90 size += vn_sizeof_uint32_t(&val->maxViewports);
91 size += vn_sizeof_array_size(2);
92 size += vn_sizeof_uint32_t_array(val->maxViewportDimensions, 2);
93 size += vn_sizeof_array_size(2);
94 size += vn_sizeof_float_array(val->viewportBoundsRange, 2);
95 size += vn_sizeof_uint32_t(&val->viewportSubPixelBits);
96 size += vn_sizeof_size_t(&val->minMemoryMapAlignment);
97 size += vn_sizeof_VkDeviceSize(&val->minTexelBufferOffsetAlignment);
98 size += vn_sizeof_VkDeviceSize(&val->minUniformBufferOffsetAlignment);
99 size += vn_sizeof_VkDeviceSize(&val->minStorageBufferOffsetAlignment);
100 size += vn_sizeof_int32_t(&val->minTexelOffset);
101 size += vn_sizeof_uint32_t(&val->maxTexelOffset);
102 size += vn_sizeof_int32_t(&val->minTexelGatherOffset);
103 size += vn_sizeof_uint32_t(&val->maxTexelGatherOffset);
104 size += vn_sizeof_float(&val->minInterpolationOffset);
105 size += vn_sizeof_float(&val->maxInterpolationOffset);
106 size += vn_sizeof_uint32_t(&val->subPixelInterpolationOffsetBits);
107 size += vn_sizeof_uint32_t(&val->maxFramebufferWidth);
108 size += vn_sizeof_uint32_t(&val->maxFramebufferHeight);
109 size += vn_sizeof_uint32_t(&val->maxFramebufferLayers);
110 size += vn_sizeof_VkFlags(&val->framebufferColorSampleCounts);
111 size += vn_sizeof_VkFlags(&val->framebufferDepthSampleCounts);
112 size += vn_sizeof_VkFlags(&val->framebufferStencilSampleCounts);
113 size += vn_sizeof_VkFlags(&val->framebufferNoAttachmentsSampleCounts);
114 size += vn_sizeof_uint32_t(&val->maxColorAttachments);
115 size += vn_sizeof_VkFlags(&val->sampledImageColorSampleCounts);
116 size += vn_sizeof_VkFlags(&val->sampledImageIntegerSampleCounts);
117 size += vn_sizeof_VkFlags(&val->sampledImageDepthSampleCounts);
118 size += vn_sizeof_VkFlags(&val->sampledImageStencilSampleCounts);
119 size += vn_sizeof_VkFlags(&val->storageImageSampleCounts);
120 size += vn_sizeof_uint32_t(&val->maxSampleMaskWords);
121 size += vn_sizeof_VkBool32(&val->timestampComputeAndGraphics);
122 size += vn_sizeof_float(&val->timestampPeriod);
123 size += vn_sizeof_uint32_t(&val->maxClipDistances);
124 size += vn_sizeof_uint32_t(&val->maxCullDistances);
125 size += vn_sizeof_uint32_t(&val->maxCombinedClipAndCullDistances);
126 size += vn_sizeof_uint32_t(&val->discreteQueuePriorities);
127 size += vn_sizeof_array_size(2);
128 size += vn_sizeof_float_array(val->pointSizeRange, 2);
129 size += vn_sizeof_array_size(2);
130 size += vn_sizeof_float_array(val->lineWidthRange, 2);
131 size += vn_sizeof_float(&val->pointSizeGranularity);
132 size += vn_sizeof_float(&val->lineWidthGranularity);
133 size += vn_sizeof_VkBool32(&val->strictLines);
134 size += vn_sizeof_VkBool32(&val->standardSampleLocations);
135 size += vn_sizeof_VkDeviceSize(&val->optimalBufferCopyOffsetAlignment);
136 size += vn_sizeof_VkDeviceSize(&val->optimalBufferCopyRowPitchAlignment);
137 size += vn_sizeof_VkDeviceSize(&val->nonCoherentAtomSize);
138 return size;
139 }
140
141 static inline void
vn_decode_VkPhysicalDeviceLimits(struct vn_cs_decoder * dec,VkPhysicalDeviceLimits * val)142 vn_decode_VkPhysicalDeviceLimits(struct vn_cs_decoder *dec, VkPhysicalDeviceLimits *val)
143 {
144 vn_decode_uint32_t(dec, &val->maxImageDimension1D);
145 vn_decode_uint32_t(dec, &val->maxImageDimension2D);
146 vn_decode_uint32_t(dec, &val->maxImageDimension3D);
147 vn_decode_uint32_t(dec, &val->maxImageDimensionCube);
148 vn_decode_uint32_t(dec, &val->maxImageArrayLayers);
149 vn_decode_uint32_t(dec, &val->maxTexelBufferElements);
150 vn_decode_uint32_t(dec, &val->maxUniformBufferRange);
151 vn_decode_uint32_t(dec, &val->maxStorageBufferRange);
152 vn_decode_uint32_t(dec, &val->maxPushConstantsSize);
153 vn_decode_uint32_t(dec, &val->maxMemoryAllocationCount);
154 vn_decode_uint32_t(dec, &val->maxSamplerAllocationCount);
155 vn_decode_VkDeviceSize(dec, &val->bufferImageGranularity);
156 vn_decode_VkDeviceSize(dec, &val->sparseAddressSpaceSize);
157 vn_decode_uint32_t(dec, &val->maxBoundDescriptorSets);
158 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorSamplers);
159 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUniformBuffers);
160 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorStorageBuffers);
161 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorSampledImages);
162 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorStorageImages);
163 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorInputAttachments);
164 vn_decode_uint32_t(dec, &val->maxPerStageResources);
165 vn_decode_uint32_t(dec, &val->maxDescriptorSetSamplers);
166 vn_decode_uint32_t(dec, &val->maxDescriptorSetUniformBuffers);
167 vn_decode_uint32_t(dec, &val->maxDescriptorSetUniformBuffersDynamic);
168 vn_decode_uint32_t(dec, &val->maxDescriptorSetStorageBuffers);
169 vn_decode_uint32_t(dec, &val->maxDescriptorSetStorageBuffersDynamic);
170 vn_decode_uint32_t(dec, &val->maxDescriptorSetSampledImages);
171 vn_decode_uint32_t(dec, &val->maxDescriptorSetStorageImages);
172 vn_decode_uint32_t(dec, &val->maxDescriptorSetInputAttachments);
173 vn_decode_uint32_t(dec, &val->maxVertexInputAttributes);
174 vn_decode_uint32_t(dec, &val->maxVertexInputBindings);
175 vn_decode_uint32_t(dec, &val->maxVertexInputAttributeOffset);
176 vn_decode_uint32_t(dec, &val->maxVertexInputBindingStride);
177 vn_decode_uint32_t(dec, &val->maxVertexOutputComponents);
178 vn_decode_uint32_t(dec, &val->maxTessellationGenerationLevel);
179 vn_decode_uint32_t(dec, &val->maxTessellationPatchSize);
180 vn_decode_uint32_t(dec, &val->maxTessellationControlPerVertexInputComponents);
181 vn_decode_uint32_t(dec, &val->maxTessellationControlPerVertexOutputComponents);
182 vn_decode_uint32_t(dec, &val->maxTessellationControlPerPatchOutputComponents);
183 vn_decode_uint32_t(dec, &val->maxTessellationControlTotalOutputComponents);
184 vn_decode_uint32_t(dec, &val->maxTessellationEvaluationInputComponents);
185 vn_decode_uint32_t(dec, &val->maxTessellationEvaluationOutputComponents);
186 vn_decode_uint32_t(dec, &val->maxGeometryShaderInvocations);
187 vn_decode_uint32_t(dec, &val->maxGeometryInputComponents);
188 vn_decode_uint32_t(dec, &val->maxGeometryOutputComponents);
189 vn_decode_uint32_t(dec, &val->maxGeometryOutputVertices);
190 vn_decode_uint32_t(dec, &val->maxGeometryTotalOutputComponents);
191 vn_decode_uint32_t(dec, &val->maxFragmentInputComponents);
192 vn_decode_uint32_t(dec, &val->maxFragmentOutputAttachments);
193 vn_decode_uint32_t(dec, &val->maxFragmentDualSrcAttachments);
194 vn_decode_uint32_t(dec, &val->maxFragmentCombinedOutputResources);
195 vn_decode_uint32_t(dec, &val->maxComputeSharedMemorySize);
196 {
197 const size_t array_size = vn_decode_array_size(dec, 3);
198 vn_decode_uint32_t_array(dec, val->maxComputeWorkGroupCount, array_size);
199 }
200 vn_decode_uint32_t(dec, &val->maxComputeWorkGroupInvocations);
201 {
202 const size_t array_size = vn_decode_array_size(dec, 3);
203 vn_decode_uint32_t_array(dec, val->maxComputeWorkGroupSize, array_size);
204 }
205 vn_decode_uint32_t(dec, &val->subPixelPrecisionBits);
206 vn_decode_uint32_t(dec, &val->subTexelPrecisionBits);
207 vn_decode_uint32_t(dec, &val->mipmapPrecisionBits);
208 vn_decode_uint32_t(dec, &val->maxDrawIndexedIndexValue);
209 vn_decode_uint32_t(dec, &val->maxDrawIndirectCount);
210 vn_decode_float(dec, &val->maxSamplerLodBias);
211 vn_decode_float(dec, &val->maxSamplerAnisotropy);
212 vn_decode_uint32_t(dec, &val->maxViewports);
213 {
214 const size_t array_size = vn_decode_array_size(dec, 2);
215 vn_decode_uint32_t_array(dec, val->maxViewportDimensions, array_size);
216 }
217 {
218 const size_t array_size = vn_decode_array_size(dec, 2);
219 vn_decode_float_array(dec, val->viewportBoundsRange, array_size);
220 }
221 vn_decode_uint32_t(dec, &val->viewportSubPixelBits);
222 vn_decode_size_t(dec, &val->minMemoryMapAlignment);
223 vn_decode_VkDeviceSize(dec, &val->minTexelBufferOffsetAlignment);
224 vn_decode_VkDeviceSize(dec, &val->minUniformBufferOffsetAlignment);
225 vn_decode_VkDeviceSize(dec, &val->minStorageBufferOffsetAlignment);
226 vn_decode_int32_t(dec, &val->minTexelOffset);
227 vn_decode_uint32_t(dec, &val->maxTexelOffset);
228 vn_decode_int32_t(dec, &val->minTexelGatherOffset);
229 vn_decode_uint32_t(dec, &val->maxTexelGatherOffset);
230 vn_decode_float(dec, &val->minInterpolationOffset);
231 vn_decode_float(dec, &val->maxInterpolationOffset);
232 vn_decode_uint32_t(dec, &val->subPixelInterpolationOffsetBits);
233 vn_decode_uint32_t(dec, &val->maxFramebufferWidth);
234 vn_decode_uint32_t(dec, &val->maxFramebufferHeight);
235 vn_decode_uint32_t(dec, &val->maxFramebufferLayers);
236 vn_decode_VkFlags(dec, &val->framebufferColorSampleCounts);
237 vn_decode_VkFlags(dec, &val->framebufferDepthSampleCounts);
238 vn_decode_VkFlags(dec, &val->framebufferStencilSampleCounts);
239 vn_decode_VkFlags(dec, &val->framebufferNoAttachmentsSampleCounts);
240 vn_decode_uint32_t(dec, &val->maxColorAttachments);
241 vn_decode_VkFlags(dec, &val->sampledImageColorSampleCounts);
242 vn_decode_VkFlags(dec, &val->sampledImageIntegerSampleCounts);
243 vn_decode_VkFlags(dec, &val->sampledImageDepthSampleCounts);
244 vn_decode_VkFlags(dec, &val->sampledImageStencilSampleCounts);
245 vn_decode_VkFlags(dec, &val->storageImageSampleCounts);
246 vn_decode_uint32_t(dec, &val->maxSampleMaskWords);
247 vn_decode_VkBool32(dec, &val->timestampComputeAndGraphics);
248 vn_decode_float(dec, &val->timestampPeriod);
249 vn_decode_uint32_t(dec, &val->maxClipDistances);
250 vn_decode_uint32_t(dec, &val->maxCullDistances);
251 vn_decode_uint32_t(dec, &val->maxCombinedClipAndCullDistances);
252 vn_decode_uint32_t(dec, &val->discreteQueuePriorities);
253 {
254 const size_t array_size = vn_decode_array_size(dec, 2);
255 vn_decode_float_array(dec, val->pointSizeRange, array_size);
256 }
257 {
258 const size_t array_size = vn_decode_array_size(dec, 2);
259 vn_decode_float_array(dec, val->lineWidthRange, array_size);
260 }
261 vn_decode_float(dec, &val->pointSizeGranularity);
262 vn_decode_float(dec, &val->lineWidthGranularity);
263 vn_decode_VkBool32(dec, &val->strictLines);
264 vn_decode_VkBool32(dec, &val->standardSampleLocations);
265 vn_decode_VkDeviceSize(dec, &val->optimalBufferCopyOffsetAlignment);
266 vn_decode_VkDeviceSize(dec, &val->optimalBufferCopyRowPitchAlignment);
267 vn_decode_VkDeviceSize(dec, &val->nonCoherentAtomSize);
268 }
269
270 static inline size_t
vn_sizeof_VkPhysicalDeviceLimits_partial(const VkPhysicalDeviceLimits * val)271 vn_sizeof_VkPhysicalDeviceLimits_partial(const VkPhysicalDeviceLimits *val)
272 {
273 size_t size = 0;
274 /* skip val->maxImageDimension1D */
275 /* skip val->maxImageDimension2D */
276 /* skip val->maxImageDimension3D */
277 /* skip val->maxImageDimensionCube */
278 /* skip val->maxImageArrayLayers */
279 /* skip val->maxTexelBufferElements */
280 /* skip val->maxUniformBufferRange */
281 /* skip val->maxStorageBufferRange */
282 /* skip val->maxPushConstantsSize */
283 /* skip val->maxMemoryAllocationCount */
284 /* skip val->maxSamplerAllocationCount */
285 /* skip val->bufferImageGranularity */
286 /* skip val->sparseAddressSpaceSize */
287 /* skip val->maxBoundDescriptorSets */
288 /* skip val->maxPerStageDescriptorSamplers */
289 /* skip val->maxPerStageDescriptorUniformBuffers */
290 /* skip val->maxPerStageDescriptorStorageBuffers */
291 /* skip val->maxPerStageDescriptorSampledImages */
292 /* skip val->maxPerStageDescriptorStorageImages */
293 /* skip val->maxPerStageDescriptorInputAttachments */
294 /* skip val->maxPerStageResources */
295 /* skip val->maxDescriptorSetSamplers */
296 /* skip val->maxDescriptorSetUniformBuffers */
297 /* skip val->maxDescriptorSetUniformBuffersDynamic */
298 /* skip val->maxDescriptorSetStorageBuffers */
299 /* skip val->maxDescriptorSetStorageBuffersDynamic */
300 /* skip val->maxDescriptorSetSampledImages */
301 /* skip val->maxDescriptorSetStorageImages */
302 /* skip val->maxDescriptorSetInputAttachments */
303 /* skip val->maxVertexInputAttributes */
304 /* skip val->maxVertexInputBindings */
305 /* skip val->maxVertexInputAttributeOffset */
306 /* skip val->maxVertexInputBindingStride */
307 /* skip val->maxVertexOutputComponents */
308 /* skip val->maxTessellationGenerationLevel */
309 /* skip val->maxTessellationPatchSize */
310 /* skip val->maxTessellationControlPerVertexInputComponents */
311 /* skip val->maxTessellationControlPerVertexOutputComponents */
312 /* skip val->maxTessellationControlPerPatchOutputComponents */
313 /* skip val->maxTessellationControlTotalOutputComponents */
314 /* skip val->maxTessellationEvaluationInputComponents */
315 /* skip val->maxTessellationEvaluationOutputComponents */
316 /* skip val->maxGeometryShaderInvocations */
317 /* skip val->maxGeometryInputComponents */
318 /* skip val->maxGeometryOutputComponents */
319 /* skip val->maxGeometryOutputVertices */
320 /* skip val->maxGeometryTotalOutputComponents */
321 /* skip val->maxFragmentInputComponents */
322 /* skip val->maxFragmentOutputAttachments */
323 /* skip val->maxFragmentDualSrcAttachments */
324 /* skip val->maxFragmentCombinedOutputResources */
325 /* skip val->maxComputeSharedMemorySize */
326 /* skip val->maxComputeWorkGroupCount */
327 /* skip val->maxComputeWorkGroupInvocations */
328 /* skip val->maxComputeWorkGroupSize */
329 /* skip val->subPixelPrecisionBits */
330 /* skip val->subTexelPrecisionBits */
331 /* skip val->mipmapPrecisionBits */
332 /* skip val->maxDrawIndexedIndexValue */
333 /* skip val->maxDrawIndirectCount */
334 /* skip val->maxSamplerLodBias */
335 /* skip val->maxSamplerAnisotropy */
336 /* skip val->maxViewports */
337 /* skip val->maxViewportDimensions */
338 /* skip val->viewportBoundsRange */
339 /* skip val->viewportSubPixelBits */
340 /* skip val->minMemoryMapAlignment */
341 /* skip val->minTexelBufferOffsetAlignment */
342 /* skip val->minUniformBufferOffsetAlignment */
343 /* skip val->minStorageBufferOffsetAlignment */
344 /* skip val->minTexelOffset */
345 /* skip val->maxTexelOffset */
346 /* skip val->minTexelGatherOffset */
347 /* skip val->maxTexelGatherOffset */
348 /* skip val->minInterpolationOffset */
349 /* skip val->maxInterpolationOffset */
350 /* skip val->subPixelInterpolationOffsetBits */
351 /* skip val->maxFramebufferWidth */
352 /* skip val->maxFramebufferHeight */
353 /* skip val->maxFramebufferLayers */
354 /* skip val->framebufferColorSampleCounts */
355 /* skip val->framebufferDepthSampleCounts */
356 /* skip val->framebufferStencilSampleCounts */
357 /* skip val->framebufferNoAttachmentsSampleCounts */
358 /* skip val->maxColorAttachments */
359 /* skip val->sampledImageColorSampleCounts */
360 /* skip val->sampledImageIntegerSampleCounts */
361 /* skip val->sampledImageDepthSampleCounts */
362 /* skip val->sampledImageStencilSampleCounts */
363 /* skip val->storageImageSampleCounts */
364 /* skip val->maxSampleMaskWords */
365 /* skip val->timestampComputeAndGraphics */
366 /* skip val->timestampPeriod */
367 /* skip val->maxClipDistances */
368 /* skip val->maxCullDistances */
369 /* skip val->maxCombinedClipAndCullDistances */
370 /* skip val->discreteQueuePriorities */
371 /* skip val->pointSizeRange */
372 /* skip val->lineWidthRange */
373 /* skip val->pointSizeGranularity */
374 /* skip val->lineWidthGranularity */
375 /* skip val->strictLines */
376 /* skip val->standardSampleLocations */
377 /* skip val->optimalBufferCopyOffsetAlignment */
378 /* skip val->optimalBufferCopyRowPitchAlignment */
379 /* skip val->nonCoherentAtomSize */
380 return size;
381 }
382
383 static inline void
vn_encode_VkPhysicalDeviceLimits_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceLimits * val)384 vn_encode_VkPhysicalDeviceLimits_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceLimits *val)
385 {
386 /* skip val->maxImageDimension1D */
387 /* skip val->maxImageDimension2D */
388 /* skip val->maxImageDimension3D */
389 /* skip val->maxImageDimensionCube */
390 /* skip val->maxImageArrayLayers */
391 /* skip val->maxTexelBufferElements */
392 /* skip val->maxUniformBufferRange */
393 /* skip val->maxStorageBufferRange */
394 /* skip val->maxPushConstantsSize */
395 /* skip val->maxMemoryAllocationCount */
396 /* skip val->maxSamplerAllocationCount */
397 /* skip val->bufferImageGranularity */
398 /* skip val->sparseAddressSpaceSize */
399 /* skip val->maxBoundDescriptorSets */
400 /* skip val->maxPerStageDescriptorSamplers */
401 /* skip val->maxPerStageDescriptorUniformBuffers */
402 /* skip val->maxPerStageDescriptorStorageBuffers */
403 /* skip val->maxPerStageDescriptorSampledImages */
404 /* skip val->maxPerStageDescriptorStorageImages */
405 /* skip val->maxPerStageDescriptorInputAttachments */
406 /* skip val->maxPerStageResources */
407 /* skip val->maxDescriptorSetSamplers */
408 /* skip val->maxDescriptorSetUniformBuffers */
409 /* skip val->maxDescriptorSetUniformBuffersDynamic */
410 /* skip val->maxDescriptorSetStorageBuffers */
411 /* skip val->maxDescriptorSetStorageBuffersDynamic */
412 /* skip val->maxDescriptorSetSampledImages */
413 /* skip val->maxDescriptorSetStorageImages */
414 /* skip val->maxDescriptorSetInputAttachments */
415 /* skip val->maxVertexInputAttributes */
416 /* skip val->maxVertexInputBindings */
417 /* skip val->maxVertexInputAttributeOffset */
418 /* skip val->maxVertexInputBindingStride */
419 /* skip val->maxVertexOutputComponents */
420 /* skip val->maxTessellationGenerationLevel */
421 /* skip val->maxTessellationPatchSize */
422 /* skip val->maxTessellationControlPerVertexInputComponents */
423 /* skip val->maxTessellationControlPerVertexOutputComponents */
424 /* skip val->maxTessellationControlPerPatchOutputComponents */
425 /* skip val->maxTessellationControlTotalOutputComponents */
426 /* skip val->maxTessellationEvaluationInputComponents */
427 /* skip val->maxTessellationEvaluationOutputComponents */
428 /* skip val->maxGeometryShaderInvocations */
429 /* skip val->maxGeometryInputComponents */
430 /* skip val->maxGeometryOutputComponents */
431 /* skip val->maxGeometryOutputVertices */
432 /* skip val->maxGeometryTotalOutputComponents */
433 /* skip val->maxFragmentInputComponents */
434 /* skip val->maxFragmentOutputAttachments */
435 /* skip val->maxFragmentDualSrcAttachments */
436 /* skip val->maxFragmentCombinedOutputResources */
437 /* skip val->maxComputeSharedMemorySize */
438 /* skip val->maxComputeWorkGroupCount */
439 /* skip val->maxComputeWorkGroupInvocations */
440 /* skip val->maxComputeWorkGroupSize */
441 /* skip val->subPixelPrecisionBits */
442 /* skip val->subTexelPrecisionBits */
443 /* skip val->mipmapPrecisionBits */
444 /* skip val->maxDrawIndexedIndexValue */
445 /* skip val->maxDrawIndirectCount */
446 /* skip val->maxSamplerLodBias */
447 /* skip val->maxSamplerAnisotropy */
448 /* skip val->maxViewports */
449 /* skip val->maxViewportDimensions */
450 /* skip val->viewportBoundsRange */
451 /* skip val->viewportSubPixelBits */
452 /* skip val->minMemoryMapAlignment */
453 /* skip val->minTexelBufferOffsetAlignment */
454 /* skip val->minUniformBufferOffsetAlignment */
455 /* skip val->minStorageBufferOffsetAlignment */
456 /* skip val->minTexelOffset */
457 /* skip val->maxTexelOffset */
458 /* skip val->minTexelGatherOffset */
459 /* skip val->maxTexelGatherOffset */
460 /* skip val->minInterpolationOffset */
461 /* skip val->maxInterpolationOffset */
462 /* skip val->subPixelInterpolationOffsetBits */
463 /* skip val->maxFramebufferWidth */
464 /* skip val->maxFramebufferHeight */
465 /* skip val->maxFramebufferLayers */
466 /* skip val->framebufferColorSampleCounts */
467 /* skip val->framebufferDepthSampleCounts */
468 /* skip val->framebufferStencilSampleCounts */
469 /* skip val->framebufferNoAttachmentsSampleCounts */
470 /* skip val->maxColorAttachments */
471 /* skip val->sampledImageColorSampleCounts */
472 /* skip val->sampledImageIntegerSampleCounts */
473 /* skip val->sampledImageDepthSampleCounts */
474 /* skip val->sampledImageStencilSampleCounts */
475 /* skip val->storageImageSampleCounts */
476 /* skip val->maxSampleMaskWords */
477 /* skip val->timestampComputeAndGraphics */
478 /* skip val->timestampPeriod */
479 /* skip val->maxClipDistances */
480 /* skip val->maxCullDistances */
481 /* skip val->maxCombinedClipAndCullDistances */
482 /* skip val->discreteQueuePriorities */
483 /* skip val->pointSizeRange */
484 /* skip val->lineWidthRange */
485 /* skip val->pointSizeGranularity */
486 /* skip val->lineWidthGranularity */
487 /* skip val->strictLines */
488 /* skip val->standardSampleLocations */
489 /* skip val->optimalBufferCopyOffsetAlignment */
490 /* skip val->optimalBufferCopyRowPitchAlignment */
491 /* skip val->nonCoherentAtomSize */
492 }
493
494 /* struct VkPhysicalDeviceSparseProperties */
495
496 static inline size_t
vn_sizeof_VkPhysicalDeviceSparseProperties(const VkPhysicalDeviceSparseProperties * val)497 vn_sizeof_VkPhysicalDeviceSparseProperties(const VkPhysicalDeviceSparseProperties *val)
498 {
499 size_t size = 0;
500 size += vn_sizeof_VkBool32(&val->residencyStandard2DBlockShape);
501 size += vn_sizeof_VkBool32(&val->residencyStandard2DMultisampleBlockShape);
502 size += vn_sizeof_VkBool32(&val->residencyStandard3DBlockShape);
503 size += vn_sizeof_VkBool32(&val->residencyAlignedMipSize);
504 size += vn_sizeof_VkBool32(&val->residencyNonResidentStrict);
505 return size;
506 }
507
508 static inline void
vn_decode_VkPhysicalDeviceSparseProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceSparseProperties * val)509 vn_decode_VkPhysicalDeviceSparseProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSparseProperties *val)
510 {
511 vn_decode_VkBool32(dec, &val->residencyStandard2DBlockShape);
512 vn_decode_VkBool32(dec, &val->residencyStandard2DMultisampleBlockShape);
513 vn_decode_VkBool32(dec, &val->residencyStandard3DBlockShape);
514 vn_decode_VkBool32(dec, &val->residencyAlignedMipSize);
515 vn_decode_VkBool32(dec, &val->residencyNonResidentStrict);
516 }
517
518 static inline size_t
vn_sizeof_VkPhysicalDeviceSparseProperties_partial(const VkPhysicalDeviceSparseProperties * val)519 vn_sizeof_VkPhysicalDeviceSparseProperties_partial(const VkPhysicalDeviceSparseProperties *val)
520 {
521 size_t size = 0;
522 /* skip val->residencyStandard2DBlockShape */
523 /* skip val->residencyStandard2DMultisampleBlockShape */
524 /* skip val->residencyStandard3DBlockShape */
525 /* skip val->residencyAlignedMipSize */
526 /* skip val->residencyNonResidentStrict */
527 return size;
528 }
529
530 static inline void
vn_encode_VkPhysicalDeviceSparseProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSparseProperties * val)531 vn_encode_VkPhysicalDeviceSparseProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseProperties *val)
532 {
533 /* skip val->residencyStandard2DBlockShape */
534 /* skip val->residencyStandard2DMultisampleBlockShape */
535 /* skip val->residencyStandard3DBlockShape */
536 /* skip val->residencyAlignedMipSize */
537 /* skip val->residencyNonResidentStrict */
538 }
539
540 /* struct VkPhysicalDeviceProperties */
541
542 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties(const VkPhysicalDeviceProperties * val)543 vn_sizeof_VkPhysicalDeviceProperties(const VkPhysicalDeviceProperties *val)
544 {
545 size_t size = 0;
546 size += vn_sizeof_uint32_t(&val->apiVersion);
547 size += vn_sizeof_uint32_t(&val->driverVersion);
548 size += vn_sizeof_uint32_t(&val->vendorID);
549 size += vn_sizeof_uint32_t(&val->deviceID);
550 size += vn_sizeof_VkPhysicalDeviceType(&val->deviceType);
551 size += vn_sizeof_array_size(VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
552 size += vn_sizeof_char_array(val->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
553 size += vn_sizeof_array_size(VK_UUID_SIZE);
554 size += vn_sizeof_uint8_t_array(val->pipelineCacheUUID, VK_UUID_SIZE);
555 size += vn_sizeof_VkPhysicalDeviceLimits(&val->limits);
556 size += vn_sizeof_VkPhysicalDeviceSparseProperties(&val->sparseProperties);
557 return size;
558 }
559
560 static inline void
vn_decode_VkPhysicalDeviceProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceProperties * val)561 vn_decode_VkPhysicalDeviceProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties *val)
562 {
563 vn_decode_uint32_t(dec, &val->apiVersion);
564 vn_decode_uint32_t(dec, &val->driverVersion);
565 vn_decode_uint32_t(dec, &val->vendorID);
566 vn_decode_uint32_t(dec, &val->deviceID);
567 vn_decode_VkPhysicalDeviceType(dec, &val->deviceType);
568 {
569 const size_t array_size = vn_decode_array_size(dec, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
570 vn_decode_char_array(dec, val->deviceName, array_size);
571 }
572 {
573 const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
574 vn_decode_uint8_t_array(dec, val->pipelineCacheUUID, array_size);
575 }
576 vn_decode_VkPhysicalDeviceLimits(dec, &val->limits);
577 vn_decode_VkPhysicalDeviceSparseProperties(dec, &val->sparseProperties);
578 }
579
580 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties_partial(const VkPhysicalDeviceProperties * val)581 vn_sizeof_VkPhysicalDeviceProperties_partial(const VkPhysicalDeviceProperties *val)
582 {
583 size_t size = 0;
584 /* skip val->apiVersion */
585 /* skip val->driverVersion */
586 /* skip val->vendorID */
587 /* skip val->deviceID */
588 /* skip val->deviceType */
589 /* skip val->deviceName */
590 /* skip val->pipelineCacheUUID */
591 size += vn_sizeof_VkPhysicalDeviceLimits_partial(&val->limits);
592 size += vn_sizeof_VkPhysicalDeviceSparseProperties_partial(&val->sparseProperties);
593 return size;
594 }
595
596 static inline void
vn_encode_VkPhysicalDeviceProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProperties * val)597 vn_encode_VkPhysicalDeviceProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties *val)
598 {
599 /* skip val->apiVersion */
600 /* skip val->driverVersion */
601 /* skip val->vendorID */
602 /* skip val->deviceID */
603 /* skip val->deviceType */
604 /* skip val->deviceName */
605 /* skip val->pipelineCacheUUID */
606 vn_encode_VkPhysicalDeviceLimits_partial(enc, &val->limits);
607 vn_encode_VkPhysicalDeviceSparseProperties_partial(enc, &val->sparseProperties);
608 }
609
610 /* struct VkQueueFamilyProperties */
611
612 static inline size_t
vn_sizeof_VkQueueFamilyProperties(const VkQueueFamilyProperties * val)613 vn_sizeof_VkQueueFamilyProperties(const VkQueueFamilyProperties *val)
614 {
615 size_t size = 0;
616 size += vn_sizeof_VkFlags(&val->queueFlags);
617 size += vn_sizeof_uint32_t(&val->queueCount);
618 size += vn_sizeof_uint32_t(&val->timestampValidBits);
619 size += vn_sizeof_VkExtent3D(&val->minImageTransferGranularity);
620 return size;
621 }
622
623 static inline void
vn_decode_VkQueueFamilyProperties(struct vn_cs_decoder * dec,VkQueueFamilyProperties * val)624 vn_decode_VkQueueFamilyProperties(struct vn_cs_decoder *dec, VkQueueFamilyProperties *val)
625 {
626 vn_decode_VkFlags(dec, &val->queueFlags);
627 vn_decode_uint32_t(dec, &val->queueCount);
628 vn_decode_uint32_t(dec, &val->timestampValidBits);
629 vn_decode_VkExtent3D(dec, &val->minImageTransferGranularity);
630 }
631
632 static inline size_t
vn_sizeof_VkQueueFamilyProperties_partial(const VkQueueFamilyProperties * val)633 vn_sizeof_VkQueueFamilyProperties_partial(const VkQueueFamilyProperties *val)
634 {
635 size_t size = 0;
636 /* skip val->queueFlags */
637 /* skip val->queueCount */
638 /* skip val->timestampValidBits */
639 size += vn_sizeof_VkExtent3D_partial(&val->minImageTransferGranularity);
640 return size;
641 }
642
643 static inline void
vn_encode_VkQueueFamilyProperties_partial(struct vn_cs_encoder * enc,const VkQueueFamilyProperties * val)644 vn_encode_VkQueueFamilyProperties_partial(struct vn_cs_encoder *enc, const VkQueueFamilyProperties *val)
645 {
646 /* skip val->queueFlags */
647 /* skip val->queueCount */
648 /* skip val->timestampValidBits */
649 vn_encode_VkExtent3D_partial(enc, &val->minImageTransferGranularity);
650 }
651
652 /* struct VkMemoryType */
653
654 static inline size_t
vn_sizeof_VkMemoryType(const VkMemoryType * val)655 vn_sizeof_VkMemoryType(const VkMemoryType *val)
656 {
657 size_t size = 0;
658 size += vn_sizeof_VkFlags(&val->propertyFlags);
659 size += vn_sizeof_uint32_t(&val->heapIndex);
660 return size;
661 }
662
663 static inline void
vn_decode_VkMemoryType(struct vn_cs_decoder * dec,VkMemoryType * val)664 vn_decode_VkMemoryType(struct vn_cs_decoder *dec, VkMemoryType *val)
665 {
666 vn_decode_VkFlags(dec, &val->propertyFlags);
667 vn_decode_uint32_t(dec, &val->heapIndex);
668 }
669
670 static inline size_t
vn_sizeof_VkMemoryType_partial(const VkMemoryType * val)671 vn_sizeof_VkMemoryType_partial(const VkMemoryType *val)
672 {
673 size_t size = 0;
674 /* skip val->propertyFlags */
675 /* skip val->heapIndex */
676 return size;
677 }
678
679 static inline void
vn_encode_VkMemoryType_partial(struct vn_cs_encoder * enc,const VkMemoryType * val)680 vn_encode_VkMemoryType_partial(struct vn_cs_encoder *enc, const VkMemoryType *val)
681 {
682 /* skip val->propertyFlags */
683 /* skip val->heapIndex */
684 }
685
686 /* struct VkMemoryHeap */
687
688 static inline size_t
vn_sizeof_VkMemoryHeap(const VkMemoryHeap * val)689 vn_sizeof_VkMemoryHeap(const VkMemoryHeap *val)
690 {
691 size_t size = 0;
692 size += vn_sizeof_VkDeviceSize(&val->size);
693 size += vn_sizeof_VkFlags(&val->flags);
694 return size;
695 }
696
697 static inline void
vn_decode_VkMemoryHeap(struct vn_cs_decoder * dec,VkMemoryHeap * val)698 vn_decode_VkMemoryHeap(struct vn_cs_decoder *dec, VkMemoryHeap *val)
699 {
700 vn_decode_VkDeviceSize(dec, &val->size);
701 vn_decode_VkFlags(dec, &val->flags);
702 }
703
704 static inline size_t
vn_sizeof_VkMemoryHeap_partial(const VkMemoryHeap * val)705 vn_sizeof_VkMemoryHeap_partial(const VkMemoryHeap *val)
706 {
707 size_t size = 0;
708 /* skip val->size */
709 /* skip val->flags */
710 return size;
711 }
712
713 static inline void
vn_encode_VkMemoryHeap_partial(struct vn_cs_encoder * enc,const VkMemoryHeap * val)714 vn_encode_VkMemoryHeap_partial(struct vn_cs_encoder *enc, const VkMemoryHeap *val)
715 {
716 /* skip val->size */
717 /* skip val->flags */
718 }
719
720 /* struct VkPhysicalDeviceMemoryProperties */
721
722 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties(const VkPhysicalDeviceMemoryProperties * val)723 vn_sizeof_VkPhysicalDeviceMemoryProperties(const VkPhysicalDeviceMemoryProperties *val)
724 {
725 size_t size = 0;
726 size += vn_sizeof_uint32_t(&val->memoryTypeCount);
727 size += vn_sizeof_array_size(VK_MAX_MEMORY_TYPES);
728 for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++)
729 size += vn_sizeof_VkMemoryType(&val->memoryTypes[i]);
730 size += vn_sizeof_uint32_t(&val->memoryHeapCount);
731 size += vn_sizeof_array_size(VK_MAX_MEMORY_HEAPS);
732 for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
733 size += vn_sizeof_VkMemoryHeap(&val->memoryHeaps[i]);
734 return size;
735 }
736
737 static inline void
vn_decode_VkPhysicalDeviceMemoryProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceMemoryProperties * val)738 vn_decode_VkPhysicalDeviceMemoryProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties *val)
739 {
740 vn_decode_uint32_t(dec, &val->memoryTypeCount);
741 {
742 const uint32_t iter_count = vn_decode_array_size(dec, VK_MAX_MEMORY_TYPES);
743 for (uint32_t i = 0; i < iter_count; i++)
744 vn_decode_VkMemoryType(dec, &val->memoryTypes[i]);
745 }
746 vn_decode_uint32_t(dec, &val->memoryHeapCount);
747 {
748 const uint32_t iter_count = vn_decode_array_size(dec, VK_MAX_MEMORY_HEAPS);
749 for (uint32_t i = 0; i < iter_count; i++)
750 vn_decode_VkMemoryHeap(dec, &val->memoryHeaps[i]);
751 }
752 }
753
754 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(const VkPhysicalDeviceMemoryProperties * val)755 vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(const VkPhysicalDeviceMemoryProperties *val)
756 {
757 size_t size = 0;
758 /* skip val->memoryTypeCount */
759 size += vn_sizeof_array_size(VK_MAX_MEMORY_TYPES);
760 for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++)
761 size += vn_sizeof_VkMemoryType_partial(&val->memoryTypes[i]);
762 /* skip val->memoryHeapCount */
763 size += vn_sizeof_array_size(VK_MAX_MEMORY_HEAPS);
764 for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
765 size += vn_sizeof_VkMemoryHeap_partial(&val->memoryHeaps[i]);
766 return size;
767 }
768
769 static inline void
vn_encode_VkPhysicalDeviceMemoryProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMemoryProperties * val)770 vn_encode_VkPhysicalDeviceMemoryProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties *val)
771 {
772 /* skip val->memoryTypeCount */
773 vn_encode_array_size(enc, VK_MAX_MEMORY_TYPES);
774 for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++)
775 vn_encode_VkMemoryType_partial(enc, &val->memoryTypes[i]);
776 /* skip val->memoryHeapCount */
777 vn_encode_array_size(enc, VK_MAX_MEMORY_HEAPS);
778 for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
779 vn_encode_VkMemoryHeap_partial(enc, &val->memoryHeaps[i]);
780 }
781
782 /* struct VkPhysicalDeviceFeatures */
783
784 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures(const VkPhysicalDeviceFeatures * val)785 vn_sizeof_VkPhysicalDeviceFeatures(const VkPhysicalDeviceFeatures *val)
786 {
787 size_t size = 0;
788 size += vn_sizeof_VkBool32(&val->robustBufferAccess);
789 size += vn_sizeof_VkBool32(&val->fullDrawIndexUint32);
790 size += vn_sizeof_VkBool32(&val->imageCubeArray);
791 size += vn_sizeof_VkBool32(&val->independentBlend);
792 size += vn_sizeof_VkBool32(&val->geometryShader);
793 size += vn_sizeof_VkBool32(&val->tessellationShader);
794 size += vn_sizeof_VkBool32(&val->sampleRateShading);
795 size += vn_sizeof_VkBool32(&val->dualSrcBlend);
796 size += vn_sizeof_VkBool32(&val->logicOp);
797 size += vn_sizeof_VkBool32(&val->multiDrawIndirect);
798 size += vn_sizeof_VkBool32(&val->drawIndirectFirstInstance);
799 size += vn_sizeof_VkBool32(&val->depthClamp);
800 size += vn_sizeof_VkBool32(&val->depthBiasClamp);
801 size += vn_sizeof_VkBool32(&val->fillModeNonSolid);
802 size += vn_sizeof_VkBool32(&val->depthBounds);
803 size += vn_sizeof_VkBool32(&val->wideLines);
804 size += vn_sizeof_VkBool32(&val->largePoints);
805 size += vn_sizeof_VkBool32(&val->alphaToOne);
806 size += vn_sizeof_VkBool32(&val->multiViewport);
807 size += vn_sizeof_VkBool32(&val->samplerAnisotropy);
808 size += vn_sizeof_VkBool32(&val->textureCompressionETC2);
809 size += vn_sizeof_VkBool32(&val->textureCompressionASTC_LDR);
810 size += vn_sizeof_VkBool32(&val->textureCompressionBC);
811 size += vn_sizeof_VkBool32(&val->occlusionQueryPrecise);
812 size += vn_sizeof_VkBool32(&val->pipelineStatisticsQuery);
813 size += vn_sizeof_VkBool32(&val->vertexPipelineStoresAndAtomics);
814 size += vn_sizeof_VkBool32(&val->fragmentStoresAndAtomics);
815 size += vn_sizeof_VkBool32(&val->shaderTessellationAndGeometryPointSize);
816 size += vn_sizeof_VkBool32(&val->shaderImageGatherExtended);
817 size += vn_sizeof_VkBool32(&val->shaderStorageImageExtendedFormats);
818 size += vn_sizeof_VkBool32(&val->shaderStorageImageMultisample);
819 size += vn_sizeof_VkBool32(&val->shaderStorageImageReadWithoutFormat);
820 size += vn_sizeof_VkBool32(&val->shaderStorageImageWriteWithoutFormat);
821 size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayDynamicIndexing);
822 size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayDynamicIndexing);
823 size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayDynamicIndexing);
824 size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayDynamicIndexing);
825 size += vn_sizeof_VkBool32(&val->shaderClipDistance);
826 size += vn_sizeof_VkBool32(&val->shaderCullDistance);
827 size += vn_sizeof_VkBool32(&val->shaderFloat64);
828 size += vn_sizeof_VkBool32(&val->shaderInt64);
829 size += vn_sizeof_VkBool32(&val->shaderInt16);
830 size += vn_sizeof_VkBool32(&val->shaderResourceResidency);
831 size += vn_sizeof_VkBool32(&val->shaderResourceMinLod);
832 size += vn_sizeof_VkBool32(&val->sparseBinding);
833 size += vn_sizeof_VkBool32(&val->sparseResidencyBuffer);
834 size += vn_sizeof_VkBool32(&val->sparseResidencyImage2D);
835 size += vn_sizeof_VkBool32(&val->sparseResidencyImage3D);
836 size += vn_sizeof_VkBool32(&val->sparseResidency2Samples);
837 size += vn_sizeof_VkBool32(&val->sparseResidency4Samples);
838 size += vn_sizeof_VkBool32(&val->sparseResidency8Samples);
839 size += vn_sizeof_VkBool32(&val->sparseResidency16Samples);
840 size += vn_sizeof_VkBool32(&val->sparseResidencyAliased);
841 size += vn_sizeof_VkBool32(&val->variableMultisampleRate);
842 size += vn_sizeof_VkBool32(&val->inheritedQueries);
843 return size;
844 }
845
846 static inline void
vn_encode_VkPhysicalDeviceFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures * val)847 vn_encode_VkPhysicalDeviceFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures *val)
848 {
849 vn_encode_VkBool32(enc, &val->robustBufferAccess);
850 vn_encode_VkBool32(enc, &val->fullDrawIndexUint32);
851 vn_encode_VkBool32(enc, &val->imageCubeArray);
852 vn_encode_VkBool32(enc, &val->independentBlend);
853 vn_encode_VkBool32(enc, &val->geometryShader);
854 vn_encode_VkBool32(enc, &val->tessellationShader);
855 vn_encode_VkBool32(enc, &val->sampleRateShading);
856 vn_encode_VkBool32(enc, &val->dualSrcBlend);
857 vn_encode_VkBool32(enc, &val->logicOp);
858 vn_encode_VkBool32(enc, &val->multiDrawIndirect);
859 vn_encode_VkBool32(enc, &val->drawIndirectFirstInstance);
860 vn_encode_VkBool32(enc, &val->depthClamp);
861 vn_encode_VkBool32(enc, &val->depthBiasClamp);
862 vn_encode_VkBool32(enc, &val->fillModeNonSolid);
863 vn_encode_VkBool32(enc, &val->depthBounds);
864 vn_encode_VkBool32(enc, &val->wideLines);
865 vn_encode_VkBool32(enc, &val->largePoints);
866 vn_encode_VkBool32(enc, &val->alphaToOne);
867 vn_encode_VkBool32(enc, &val->multiViewport);
868 vn_encode_VkBool32(enc, &val->samplerAnisotropy);
869 vn_encode_VkBool32(enc, &val->textureCompressionETC2);
870 vn_encode_VkBool32(enc, &val->textureCompressionASTC_LDR);
871 vn_encode_VkBool32(enc, &val->textureCompressionBC);
872 vn_encode_VkBool32(enc, &val->occlusionQueryPrecise);
873 vn_encode_VkBool32(enc, &val->pipelineStatisticsQuery);
874 vn_encode_VkBool32(enc, &val->vertexPipelineStoresAndAtomics);
875 vn_encode_VkBool32(enc, &val->fragmentStoresAndAtomics);
876 vn_encode_VkBool32(enc, &val->shaderTessellationAndGeometryPointSize);
877 vn_encode_VkBool32(enc, &val->shaderImageGatherExtended);
878 vn_encode_VkBool32(enc, &val->shaderStorageImageExtendedFormats);
879 vn_encode_VkBool32(enc, &val->shaderStorageImageMultisample);
880 vn_encode_VkBool32(enc, &val->shaderStorageImageReadWithoutFormat);
881 vn_encode_VkBool32(enc, &val->shaderStorageImageWriteWithoutFormat);
882 vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayDynamicIndexing);
883 vn_encode_VkBool32(enc, &val->shaderSampledImageArrayDynamicIndexing);
884 vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayDynamicIndexing);
885 vn_encode_VkBool32(enc, &val->shaderStorageImageArrayDynamicIndexing);
886 vn_encode_VkBool32(enc, &val->shaderClipDistance);
887 vn_encode_VkBool32(enc, &val->shaderCullDistance);
888 vn_encode_VkBool32(enc, &val->shaderFloat64);
889 vn_encode_VkBool32(enc, &val->shaderInt64);
890 vn_encode_VkBool32(enc, &val->shaderInt16);
891 vn_encode_VkBool32(enc, &val->shaderResourceResidency);
892 vn_encode_VkBool32(enc, &val->shaderResourceMinLod);
893 vn_encode_VkBool32(enc, &val->sparseBinding);
894 vn_encode_VkBool32(enc, &val->sparseResidencyBuffer);
895 vn_encode_VkBool32(enc, &val->sparseResidencyImage2D);
896 vn_encode_VkBool32(enc, &val->sparseResidencyImage3D);
897 vn_encode_VkBool32(enc, &val->sparseResidency2Samples);
898 vn_encode_VkBool32(enc, &val->sparseResidency4Samples);
899 vn_encode_VkBool32(enc, &val->sparseResidency8Samples);
900 vn_encode_VkBool32(enc, &val->sparseResidency16Samples);
901 vn_encode_VkBool32(enc, &val->sparseResidencyAliased);
902 vn_encode_VkBool32(enc, &val->variableMultisampleRate);
903 vn_encode_VkBool32(enc, &val->inheritedQueries);
904 }
905
906 static inline void
vn_decode_VkPhysicalDeviceFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceFeatures * val)907 vn_decode_VkPhysicalDeviceFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures *val)
908 {
909 vn_decode_VkBool32(dec, &val->robustBufferAccess);
910 vn_decode_VkBool32(dec, &val->fullDrawIndexUint32);
911 vn_decode_VkBool32(dec, &val->imageCubeArray);
912 vn_decode_VkBool32(dec, &val->independentBlend);
913 vn_decode_VkBool32(dec, &val->geometryShader);
914 vn_decode_VkBool32(dec, &val->tessellationShader);
915 vn_decode_VkBool32(dec, &val->sampleRateShading);
916 vn_decode_VkBool32(dec, &val->dualSrcBlend);
917 vn_decode_VkBool32(dec, &val->logicOp);
918 vn_decode_VkBool32(dec, &val->multiDrawIndirect);
919 vn_decode_VkBool32(dec, &val->drawIndirectFirstInstance);
920 vn_decode_VkBool32(dec, &val->depthClamp);
921 vn_decode_VkBool32(dec, &val->depthBiasClamp);
922 vn_decode_VkBool32(dec, &val->fillModeNonSolid);
923 vn_decode_VkBool32(dec, &val->depthBounds);
924 vn_decode_VkBool32(dec, &val->wideLines);
925 vn_decode_VkBool32(dec, &val->largePoints);
926 vn_decode_VkBool32(dec, &val->alphaToOne);
927 vn_decode_VkBool32(dec, &val->multiViewport);
928 vn_decode_VkBool32(dec, &val->samplerAnisotropy);
929 vn_decode_VkBool32(dec, &val->textureCompressionETC2);
930 vn_decode_VkBool32(dec, &val->textureCompressionASTC_LDR);
931 vn_decode_VkBool32(dec, &val->textureCompressionBC);
932 vn_decode_VkBool32(dec, &val->occlusionQueryPrecise);
933 vn_decode_VkBool32(dec, &val->pipelineStatisticsQuery);
934 vn_decode_VkBool32(dec, &val->vertexPipelineStoresAndAtomics);
935 vn_decode_VkBool32(dec, &val->fragmentStoresAndAtomics);
936 vn_decode_VkBool32(dec, &val->shaderTessellationAndGeometryPointSize);
937 vn_decode_VkBool32(dec, &val->shaderImageGatherExtended);
938 vn_decode_VkBool32(dec, &val->shaderStorageImageExtendedFormats);
939 vn_decode_VkBool32(dec, &val->shaderStorageImageMultisample);
940 vn_decode_VkBool32(dec, &val->shaderStorageImageReadWithoutFormat);
941 vn_decode_VkBool32(dec, &val->shaderStorageImageWriteWithoutFormat);
942 vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayDynamicIndexing);
943 vn_decode_VkBool32(dec, &val->shaderSampledImageArrayDynamicIndexing);
944 vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayDynamicIndexing);
945 vn_decode_VkBool32(dec, &val->shaderStorageImageArrayDynamicIndexing);
946 vn_decode_VkBool32(dec, &val->shaderClipDistance);
947 vn_decode_VkBool32(dec, &val->shaderCullDistance);
948 vn_decode_VkBool32(dec, &val->shaderFloat64);
949 vn_decode_VkBool32(dec, &val->shaderInt64);
950 vn_decode_VkBool32(dec, &val->shaderInt16);
951 vn_decode_VkBool32(dec, &val->shaderResourceResidency);
952 vn_decode_VkBool32(dec, &val->shaderResourceMinLod);
953 vn_decode_VkBool32(dec, &val->sparseBinding);
954 vn_decode_VkBool32(dec, &val->sparseResidencyBuffer);
955 vn_decode_VkBool32(dec, &val->sparseResidencyImage2D);
956 vn_decode_VkBool32(dec, &val->sparseResidencyImage3D);
957 vn_decode_VkBool32(dec, &val->sparseResidency2Samples);
958 vn_decode_VkBool32(dec, &val->sparseResidency4Samples);
959 vn_decode_VkBool32(dec, &val->sparseResidency8Samples);
960 vn_decode_VkBool32(dec, &val->sparseResidency16Samples);
961 vn_decode_VkBool32(dec, &val->sparseResidencyAliased);
962 vn_decode_VkBool32(dec, &val->variableMultisampleRate);
963 vn_decode_VkBool32(dec, &val->inheritedQueries);
964 }
965
966 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures_partial(const VkPhysicalDeviceFeatures * val)967 vn_sizeof_VkPhysicalDeviceFeatures_partial(const VkPhysicalDeviceFeatures *val)
968 {
969 size_t size = 0;
970 /* skip val->robustBufferAccess */
971 /* skip val->fullDrawIndexUint32 */
972 /* skip val->imageCubeArray */
973 /* skip val->independentBlend */
974 /* skip val->geometryShader */
975 /* skip val->tessellationShader */
976 /* skip val->sampleRateShading */
977 /* skip val->dualSrcBlend */
978 /* skip val->logicOp */
979 /* skip val->multiDrawIndirect */
980 /* skip val->drawIndirectFirstInstance */
981 /* skip val->depthClamp */
982 /* skip val->depthBiasClamp */
983 /* skip val->fillModeNonSolid */
984 /* skip val->depthBounds */
985 /* skip val->wideLines */
986 /* skip val->largePoints */
987 /* skip val->alphaToOne */
988 /* skip val->multiViewport */
989 /* skip val->samplerAnisotropy */
990 /* skip val->textureCompressionETC2 */
991 /* skip val->textureCompressionASTC_LDR */
992 /* skip val->textureCompressionBC */
993 /* skip val->occlusionQueryPrecise */
994 /* skip val->pipelineStatisticsQuery */
995 /* skip val->vertexPipelineStoresAndAtomics */
996 /* skip val->fragmentStoresAndAtomics */
997 /* skip val->shaderTessellationAndGeometryPointSize */
998 /* skip val->shaderImageGatherExtended */
999 /* skip val->shaderStorageImageExtendedFormats */
1000 /* skip val->shaderStorageImageMultisample */
1001 /* skip val->shaderStorageImageReadWithoutFormat */
1002 /* skip val->shaderStorageImageWriteWithoutFormat */
1003 /* skip val->shaderUniformBufferArrayDynamicIndexing */
1004 /* skip val->shaderSampledImageArrayDynamicIndexing */
1005 /* skip val->shaderStorageBufferArrayDynamicIndexing */
1006 /* skip val->shaderStorageImageArrayDynamicIndexing */
1007 /* skip val->shaderClipDistance */
1008 /* skip val->shaderCullDistance */
1009 /* skip val->shaderFloat64 */
1010 /* skip val->shaderInt64 */
1011 /* skip val->shaderInt16 */
1012 /* skip val->shaderResourceResidency */
1013 /* skip val->shaderResourceMinLod */
1014 /* skip val->sparseBinding */
1015 /* skip val->sparseResidencyBuffer */
1016 /* skip val->sparseResidencyImage2D */
1017 /* skip val->sparseResidencyImage3D */
1018 /* skip val->sparseResidency2Samples */
1019 /* skip val->sparseResidency4Samples */
1020 /* skip val->sparseResidency8Samples */
1021 /* skip val->sparseResidency16Samples */
1022 /* skip val->sparseResidencyAliased */
1023 /* skip val->variableMultisampleRate */
1024 /* skip val->inheritedQueries */
1025 return size;
1026 }
1027
1028 static inline void
vn_encode_VkPhysicalDeviceFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures * val)1029 vn_encode_VkPhysicalDeviceFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures *val)
1030 {
1031 /* skip val->robustBufferAccess */
1032 /* skip val->fullDrawIndexUint32 */
1033 /* skip val->imageCubeArray */
1034 /* skip val->independentBlend */
1035 /* skip val->geometryShader */
1036 /* skip val->tessellationShader */
1037 /* skip val->sampleRateShading */
1038 /* skip val->dualSrcBlend */
1039 /* skip val->logicOp */
1040 /* skip val->multiDrawIndirect */
1041 /* skip val->drawIndirectFirstInstance */
1042 /* skip val->depthClamp */
1043 /* skip val->depthBiasClamp */
1044 /* skip val->fillModeNonSolid */
1045 /* skip val->depthBounds */
1046 /* skip val->wideLines */
1047 /* skip val->largePoints */
1048 /* skip val->alphaToOne */
1049 /* skip val->multiViewport */
1050 /* skip val->samplerAnisotropy */
1051 /* skip val->textureCompressionETC2 */
1052 /* skip val->textureCompressionASTC_LDR */
1053 /* skip val->textureCompressionBC */
1054 /* skip val->occlusionQueryPrecise */
1055 /* skip val->pipelineStatisticsQuery */
1056 /* skip val->vertexPipelineStoresAndAtomics */
1057 /* skip val->fragmentStoresAndAtomics */
1058 /* skip val->shaderTessellationAndGeometryPointSize */
1059 /* skip val->shaderImageGatherExtended */
1060 /* skip val->shaderStorageImageExtendedFormats */
1061 /* skip val->shaderStorageImageMultisample */
1062 /* skip val->shaderStorageImageReadWithoutFormat */
1063 /* skip val->shaderStorageImageWriteWithoutFormat */
1064 /* skip val->shaderUniformBufferArrayDynamicIndexing */
1065 /* skip val->shaderSampledImageArrayDynamicIndexing */
1066 /* skip val->shaderStorageBufferArrayDynamicIndexing */
1067 /* skip val->shaderStorageImageArrayDynamicIndexing */
1068 /* skip val->shaderClipDistance */
1069 /* skip val->shaderCullDistance */
1070 /* skip val->shaderFloat64 */
1071 /* skip val->shaderInt64 */
1072 /* skip val->shaderInt16 */
1073 /* skip val->shaderResourceResidency */
1074 /* skip val->shaderResourceMinLod */
1075 /* skip val->sparseBinding */
1076 /* skip val->sparseResidencyBuffer */
1077 /* skip val->sparseResidencyImage2D */
1078 /* skip val->sparseResidencyImage3D */
1079 /* skip val->sparseResidency2Samples */
1080 /* skip val->sparseResidency4Samples */
1081 /* skip val->sparseResidency8Samples */
1082 /* skip val->sparseResidency16Samples */
1083 /* skip val->sparseResidencyAliased */
1084 /* skip val->variableMultisampleRate */
1085 /* skip val->inheritedQueries */
1086 }
1087
1088 /* struct VkFormatProperties */
1089
1090 static inline size_t
vn_sizeof_VkFormatProperties(const VkFormatProperties * val)1091 vn_sizeof_VkFormatProperties(const VkFormatProperties *val)
1092 {
1093 size_t size = 0;
1094 size += vn_sizeof_VkFlags(&val->linearTilingFeatures);
1095 size += vn_sizeof_VkFlags(&val->optimalTilingFeatures);
1096 size += vn_sizeof_VkFlags(&val->bufferFeatures);
1097 return size;
1098 }
1099
1100 static inline void
vn_decode_VkFormatProperties(struct vn_cs_decoder * dec,VkFormatProperties * val)1101 vn_decode_VkFormatProperties(struct vn_cs_decoder *dec, VkFormatProperties *val)
1102 {
1103 vn_decode_VkFlags(dec, &val->linearTilingFeatures);
1104 vn_decode_VkFlags(dec, &val->optimalTilingFeatures);
1105 vn_decode_VkFlags(dec, &val->bufferFeatures);
1106 }
1107
1108 static inline size_t
vn_sizeof_VkFormatProperties_partial(const VkFormatProperties * val)1109 vn_sizeof_VkFormatProperties_partial(const VkFormatProperties *val)
1110 {
1111 size_t size = 0;
1112 /* skip val->linearTilingFeatures */
1113 /* skip val->optimalTilingFeatures */
1114 /* skip val->bufferFeatures */
1115 return size;
1116 }
1117
1118 static inline void
vn_encode_VkFormatProperties_partial(struct vn_cs_encoder * enc,const VkFormatProperties * val)1119 vn_encode_VkFormatProperties_partial(struct vn_cs_encoder *enc, const VkFormatProperties *val)
1120 {
1121 /* skip val->linearTilingFeatures */
1122 /* skip val->optimalTilingFeatures */
1123 /* skip val->bufferFeatures */
1124 }
1125
1126 /* struct VkImageFormatProperties */
1127
1128 static inline size_t
vn_sizeof_VkImageFormatProperties(const VkImageFormatProperties * val)1129 vn_sizeof_VkImageFormatProperties(const VkImageFormatProperties *val)
1130 {
1131 size_t size = 0;
1132 size += vn_sizeof_VkExtent3D(&val->maxExtent);
1133 size += vn_sizeof_uint32_t(&val->maxMipLevels);
1134 size += vn_sizeof_uint32_t(&val->maxArrayLayers);
1135 size += vn_sizeof_VkFlags(&val->sampleCounts);
1136 size += vn_sizeof_VkDeviceSize(&val->maxResourceSize);
1137 return size;
1138 }
1139
1140 static inline void
vn_decode_VkImageFormatProperties(struct vn_cs_decoder * dec,VkImageFormatProperties * val)1141 vn_decode_VkImageFormatProperties(struct vn_cs_decoder *dec, VkImageFormatProperties *val)
1142 {
1143 vn_decode_VkExtent3D(dec, &val->maxExtent);
1144 vn_decode_uint32_t(dec, &val->maxMipLevels);
1145 vn_decode_uint32_t(dec, &val->maxArrayLayers);
1146 vn_decode_VkFlags(dec, &val->sampleCounts);
1147 vn_decode_VkDeviceSize(dec, &val->maxResourceSize);
1148 }
1149
1150 static inline size_t
vn_sizeof_VkImageFormatProperties_partial(const VkImageFormatProperties * val)1151 vn_sizeof_VkImageFormatProperties_partial(const VkImageFormatProperties *val)
1152 {
1153 size_t size = 0;
1154 size += vn_sizeof_VkExtent3D_partial(&val->maxExtent);
1155 /* skip val->maxMipLevels */
1156 /* skip val->maxArrayLayers */
1157 /* skip val->sampleCounts */
1158 /* skip val->maxResourceSize */
1159 return size;
1160 }
1161
1162 static inline void
vn_encode_VkImageFormatProperties_partial(struct vn_cs_encoder * enc,const VkImageFormatProperties * val)1163 vn_encode_VkImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkImageFormatProperties *val)
1164 {
1165 vn_encode_VkExtent3D_partial(enc, &val->maxExtent);
1166 /* skip val->maxMipLevels */
1167 /* skip val->maxArrayLayers */
1168 /* skip val->sampleCounts */
1169 /* skip val->maxResourceSize */
1170 }
1171
1172 /* struct VkDeviceQueueCreateInfo chain */
1173
1174 static inline size_t
vn_sizeof_VkDeviceQueueCreateInfo_pnext(const void * val)1175 vn_sizeof_VkDeviceQueueCreateInfo_pnext(const void *val)
1176 {
1177 /* no known/supported struct */
1178 return vn_sizeof_simple_pointer(NULL);
1179 }
1180
1181 static inline size_t
vn_sizeof_VkDeviceQueueCreateInfo_self(const VkDeviceQueueCreateInfo * val)1182 vn_sizeof_VkDeviceQueueCreateInfo_self(const VkDeviceQueueCreateInfo *val)
1183 {
1184 size_t size = 0;
1185 /* skip val->{sType,pNext} */
1186 size += vn_sizeof_VkFlags(&val->flags);
1187 size += vn_sizeof_uint32_t(&val->queueFamilyIndex);
1188 size += vn_sizeof_uint32_t(&val->queueCount);
1189 if (val->pQueuePriorities) {
1190 size += vn_sizeof_array_size(val->queueCount);
1191 size += vn_sizeof_float_array(val->pQueuePriorities, val->queueCount);
1192 } else {
1193 size += vn_sizeof_array_size(0);
1194 }
1195 return size;
1196 }
1197
1198 static inline size_t
vn_sizeof_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo * val)1199 vn_sizeof_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo *val)
1200 {
1201 size_t size = 0;
1202
1203 size += vn_sizeof_VkStructureType(&val->sType);
1204 size += vn_sizeof_VkDeviceQueueCreateInfo_pnext(val->pNext);
1205 size += vn_sizeof_VkDeviceQueueCreateInfo_self(val);
1206
1207 return size;
1208 }
1209
1210 static inline void
vn_encode_VkDeviceQueueCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)1211 vn_encode_VkDeviceQueueCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
1212 {
1213 /* no known/supported struct */
1214 vn_encode_simple_pointer(enc, NULL);
1215 }
1216
1217 static inline void
vn_encode_VkDeviceQueueCreateInfo_self(struct vn_cs_encoder * enc,const VkDeviceQueueCreateInfo * val)1218 vn_encode_VkDeviceQueueCreateInfo_self(struct vn_cs_encoder *enc, const VkDeviceQueueCreateInfo *val)
1219 {
1220 /* skip val->{sType,pNext} */
1221 vn_encode_VkFlags(enc, &val->flags);
1222 vn_encode_uint32_t(enc, &val->queueFamilyIndex);
1223 vn_encode_uint32_t(enc, &val->queueCount);
1224 if (val->pQueuePriorities) {
1225 vn_encode_array_size(enc, val->queueCount);
1226 vn_encode_float_array(enc, val->pQueuePriorities, val->queueCount);
1227 } else {
1228 vn_encode_array_size(enc, 0);
1229 }
1230 }
1231
1232 static inline void
vn_encode_VkDeviceQueueCreateInfo(struct vn_cs_encoder * enc,const VkDeviceQueueCreateInfo * val)1233 vn_encode_VkDeviceQueueCreateInfo(struct vn_cs_encoder *enc, const VkDeviceQueueCreateInfo *val)
1234 {
1235 assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO);
1236 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO });
1237 vn_encode_VkDeviceQueueCreateInfo_pnext(enc, val->pNext);
1238 vn_encode_VkDeviceQueueCreateInfo_self(enc, val);
1239 }
1240
1241 /* struct VkPhysicalDeviceVariablePointersFeatures chain */
1242
1243 static inline size_t
vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext(const void * val)1244 vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext(const void *val)
1245 {
1246 /* no known/supported struct */
1247 return vn_sizeof_simple_pointer(NULL);
1248 }
1249
1250 static inline size_t
vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self(const VkPhysicalDeviceVariablePointersFeatures * val)1251 vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self(const VkPhysicalDeviceVariablePointersFeatures *val)
1252 {
1253 size_t size = 0;
1254 /* skip val->{sType,pNext} */
1255 size += vn_sizeof_VkBool32(&val->variablePointersStorageBuffer);
1256 size += vn_sizeof_VkBool32(&val->variablePointers);
1257 return size;
1258 }
1259
1260 static inline size_t
vn_sizeof_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures * val)1261 vn_sizeof_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures *val)
1262 {
1263 size_t size = 0;
1264
1265 size += vn_sizeof_VkStructureType(&val->sType);
1266 size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext(val->pNext);
1267 size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self(val);
1268
1269 return size;
1270 }
1271
1272 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1273 vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1274 {
1275 /* no known/supported struct */
1276 vn_encode_simple_pointer(enc, NULL);
1277 }
1278
1279 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVariablePointersFeatures * val)1280 vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
1281 {
1282 /* skip val->{sType,pNext} */
1283 vn_encode_VkBool32(enc, &val->variablePointersStorageBuffer);
1284 vn_encode_VkBool32(enc, &val->variablePointers);
1285 }
1286
1287 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceVariablePointersFeatures * val)1288 vn_encode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
1289 {
1290 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
1291 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES });
1292 vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext(enc, val->pNext);
1293 vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, val);
1294 }
1295
1296 static inline void
vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_decoder * dec,const void * val)1297 vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
1298 {
1299 /* no known/supported struct */
1300 if (vn_decode_simple_pointer(dec))
1301 assert(false);
1302 }
1303
1304 static inline void
vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVariablePointersFeatures * val)1305 vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVariablePointersFeatures *val)
1306 {
1307 /* skip val->{sType,pNext} */
1308 vn_decode_VkBool32(dec, &val->variablePointersStorageBuffer);
1309 vn_decode_VkBool32(dec, &val->variablePointers);
1310 }
1311
1312 static inline void
vn_decode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceVariablePointersFeatures * val)1313 vn_decode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceVariablePointersFeatures *val)
1314 {
1315 VkStructureType stype;
1316 vn_decode_VkStructureType(dec, &stype);
1317 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
1318
1319 assert(val->sType == stype);
1320 vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext(dec, val->pNext);
1321 vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(dec, val);
1322 }
1323
1324 static inline size_t
vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(const void * val)1325 vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(const void *val)
1326 {
1327 /* no known/supported struct */
1328 return vn_sizeof_simple_pointer(NULL);
1329 }
1330
1331 static inline size_t
vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial(const VkPhysicalDeviceVariablePointersFeatures * val)1332 vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial(const VkPhysicalDeviceVariablePointersFeatures *val)
1333 {
1334 size_t size = 0;
1335 /* skip val->{sType,pNext} */
1336 /* skip val->variablePointersStorageBuffer */
1337 /* skip val->variablePointers */
1338 return size;
1339 }
1340
1341 static inline size_t
vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_partial(const VkPhysicalDeviceVariablePointersFeatures * val)1342 vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_partial(const VkPhysicalDeviceVariablePointersFeatures *val)
1343 {
1344 size_t size = 0;
1345
1346 size += vn_sizeof_VkStructureType(&val->sType);
1347 size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(val->pNext);
1348 size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial(val);
1349
1350 return size;
1351 }
1352
1353 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)1354 vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
1355 {
1356 /* no known/supported struct */
1357 vn_encode_simple_pointer(enc, NULL);
1358 }
1359
1360 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVariablePointersFeatures * val)1361 vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
1362 {
1363 /* skip val->{sType,pNext} */
1364 /* skip val->variablePointersStorageBuffer */
1365 /* skip val->variablePointers */
1366 }
1367
1368 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVariablePointersFeatures * val)1369 vn_encode_VkPhysicalDeviceVariablePointersFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
1370 {
1371 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
1372 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES });
1373 vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(enc, val->pNext);
1374 vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(enc, val);
1375 }
1376
1377 /* struct VkPhysicalDeviceMultiviewFeatures chain */
1378
1379 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext(const void * val)1380 vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext(const void *val)
1381 {
1382 /* no known/supported struct */
1383 return vn_sizeof_simple_pointer(NULL);
1384 }
1385
1386 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self(const VkPhysicalDeviceMultiviewFeatures * val)1387 vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self(const VkPhysicalDeviceMultiviewFeatures *val)
1388 {
1389 size_t size = 0;
1390 /* skip val->{sType,pNext} */
1391 size += vn_sizeof_VkBool32(&val->multiview);
1392 size += vn_sizeof_VkBool32(&val->multiviewGeometryShader);
1393 size += vn_sizeof_VkBool32(&val->multiviewTessellationShader);
1394 return size;
1395 }
1396
1397 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures * val)1398 vn_sizeof_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures *val)
1399 {
1400 size_t size = 0;
1401
1402 size += vn_sizeof_VkStructureType(&val->sType);
1403 size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext(val->pNext);
1404 size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self(val);
1405
1406 return size;
1407 }
1408
1409 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1410 vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1411 {
1412 /* no known/supported struct */
1413 vn_encode_simple_pointer(enc, NULL);
1414 }
1415
1416 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewFeatures * val)1417 vn_encode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
1418 {
1419 /* skip val->{sType,pNext} */
1420 vn_encode_VkBool32(enc, &val->multiview);
1421 vn_encode_VkBool32(enc, &val->multiviewGeometryShader);
1422 vn_encode_VkBool32(enc, &val->multiviewTessellationShader);
1423 }
1424
1425 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewFeatures * val)1426 vn_encode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
1427 {
1428 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
1429 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES });
1430 vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext(enc, val->pNext);
1431 vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, val);
1432 }
1433
1434 static inline void
vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_decoder * dec,const void * val)1435 vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
1436 {
1437 /* no known/supported struct */
1438 if (vn_decode_simple_pointer(dec))
1439 assert(false);
1440 }
1441
1442 static inline void
vn_decode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewFeatures * val)1443 vn_decode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewFeatures *val)
1444 {
1445 /* skip val->{sType,pNext} */
1446 vn_decode_VkBool32(dec, &val->multiview);
1447 vn_decode_VkBool32(dec, &val->multiviewGeometryShader);
1448 vn_decode_VkBool32(dec, &val->multiviewTessellationShader);
1449 }
1450
1451 static inline void
vn_decode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewFeatures * val)1452 vn_decode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewFeatures *val)
1453 {
1454 VkStructureType stype;
1455 vn_decode_VkStructureType(dec, &stype);
1456 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
1457
1458 assert(val->sType == stype);
1459 vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext(dec, val->pNext);
1460 vn_decode_VkPhysicalDeviceMultiviewFeatures_self(dec, val);
1461 }
1462
1463 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext_partial(const void * val)1464 vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext_partial(const void *val)
1465 {
1466 /* no known/supported struct */
1467 return vn_sizeof_simple_pointer(NULL);
1468 }
1469
1470 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial(const VkPhysicalDeviceMultiviewFeatures * val)1471 vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial(const VkPhysicalDeviceMultiviewFeatures *val)
1472 {
1473 size_t size = 0;
1474 /* skip val->{sType,pNext} */
1475 /* skip val->multiview */
1476 /* skip val->multiviewGeometryShader */
1477 /* skip val->multiviewTessellationShader */
1478 return size;
1479 }
1480
1481 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewFeatures_partial(const VkPhysicalDeviceMultiviewFeatures * val)1482 vn_sizeof_VkPhysicalDeviceMultiviewFeatures_partial(const VkPhysicalDeviceMultiviewFeatures *val)
1483 {
1484 size_t size = 0;
1485
1486 size += vn_sizeof_VkStructureType(&val->sType);
1487 size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext_partial(val->pNext);
1488 size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial(val);
1489
1490 return size;
1491 }
1492
1493 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)1494 vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
1495 {
1496 /* no known/supported struct */
1497 vn_encode_simple_pointer(enc, NULL);
1498 }
1499
1500 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewFeatures * val)1501 vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
1502 {
1503 /* skip val->{sType,pNext} */
1504 /* skip val->multiview */
1505 /* skip val->multiviewGeometryShader */
1506 /* skip val->multiviewTessellationShader */
1507 }
1508
1509 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewFeatures * val)1510 vn_encode_VkPhysicalDeviceMultiviewFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
1511 {
1512 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
1513 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES });
1514 vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext_partial(enc, val->pNext);
1515 vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(enc, val);
1516 }
1517
1518 /* struct VkPhysicalDevice16BitStorageFeatures chain */
1519
1520 static inline size_t
vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext(const void * val)1521 vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext(const void *val)
1522 {
1523 /* no known/supported struct */
1524 return vn_sizeof_simple_pointer(NULL);
1525 }
1526
1527 static inline size_t
vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self(const VkPhysicalDevice16BitStorageFeatures * val)1528 vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self(const VkPhysicalDevice16BitStorageFeatures *val)
1529 {
1530 size_t size = 0;
1531 /* skip val->{sType,pNext} */
1532 size += vn_sizeof_VkBool32(&val->storageBuffer16BitAccess);
1533 size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer16BitAccess);
1534 size += vn_sizeof_VkBool32(&val->storagePushConstant16);
1535 size += vn_sizeof_VkBool32(&val->storageInputOutput16);
1536 return size;
1537 }
1538
1539 static inline size_t
vn_sizeof_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures * val)1540 vn_sizeof_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures *val)
1541 {
1542 size_t size = 0;
1543
1544 size += vn_sizeof_VkStructureType(&val->sType);
1545 size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext(val->pNext);
1546 size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self(val);
1547
1548 return size;
1549 }
1550
1551 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1552 vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1553 {
1554 /* no known/supported struct */
1555 vn_encode_simple_pointer(enc, NULL);
1556 }
1557
1558 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDevice16BitStorageFeatures * val)1559 vn_encode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
1560 {
1561 /* skip val->{sType,pNext} */
1562 vn_encode_VkBool32(enc, &val->storageBuffer16BitAccess);
1563 vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer16BitAccess);
1564 vn_encode_VkBool32(enc, &val->storagePushConstant16);
1565 vn_encode_VkBool32(enc, &val->storageInputOutput16);
1566 }
1567
1568 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_encoder * enc,const VkPhysicalDevice16BitStorageFeatures * val)1569 vn_encode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
1570 {
1571 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
1572 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES });
1573 vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext(enc, val->pNext);
1574 vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, val);
1575 }
1576
1577 static inline void
vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_decoder * dec,const void * val)1578 vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
1579 {
1580 /* no known/supported struct */
1581 if (vn_decode_simple_pointer(dec))
1582 assert(false);
1583 }
1584
1585 static inline void
vn_decode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDevice16BitStorageFeatures * val)1586 vn_decode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDevice16BitStorageFeatures *val)
1587 {
1588 /* skip val->{sType,pNext} */
1589 vn_decode_VkBool32(dec, &val->storageBuffer16BitAccess);
1590 vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer16BitAccess);
1591 vn_decode_VkBool32(dec, &val->storagePushConstant16);
1592 vn_decode_VkBool32(dec, &val->storageInputOutput16);
1593 }
1594
1595 static inline void
vn_decode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_decoder * dec,VkPhysicalDevice16BitStorageFeatures * val)1596 vn_decode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_decoder *dec, VkPhysicalDevice16BitStorageFeatures *val)
1597 {
1598 VkStructureType stype;
1599 vn_decode_VkStructureType(dec, &stype);
1600 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
1601
1602 assert(val->sType == stype);
1603 vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext(dec, val->pNext);
1604 vn_decode_VkPhysicalDevice16BitStorageFeatures_self(dec, val);
1605 }
1606
1607 static inline size_t
vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext_partial(const void * val)1608 vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext_partial(const void *val)
1609 {
1610 /* no known/supported struct */
1611 return vn_sizeof_simple_pointer(NULL);
1612 }
1613
1614 static inline size_t
vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial(const VkPhysicalDevice16BitStorageFeatures * val)1615 vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial(const VkPhysicalDevice16BitStorageFeatures *val)
1616 {
1617 size_t size = 0;
1618 /* skip val->{sType,pNext} */
1619 /* skip val->storageBuffer16BitAccess */
1620 /* skip val->uniformAndStorageBuffer16BitAccess */
1621 /* skip val->storagePushConstant16 */
1622 /* skip val->storageInputOutput16 */
1623 return size;
1624 }
1625
1626 static inline size_t
vn_sizeof_VkPhysicalDevice16BitStorageFeatures_partial(const VkPhysicalDevice16BitStorageFeatures * val)1627 vn_sizeof_VkPhysicalDevice16BitStorageFeatures_partial(const VkPhysicalDevice16BitStorageFeatures *val)
1628 {
1629 size_t size = 0;
1630
1631 size += vn_sizeof_VkStructureType(&val->sType);
1632 size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext_partial(val->pNext);
1633 size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial(val);
1634
1635 return size;
1636 }
1637
1638 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)1639 vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
1640 {
1641 /* no known/supported struct */
1642 vn_encode_simple_pointer(enc, NULL);
1643 }
1644
1645 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevice16BitStorageFeatures * val)1646 vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
1647 {
1648 /* skip val->{sType,pNext} */
1649 /* skip val->storageBuffer16BitAccess */
1650 /* skip val->uniformAndStorageBuffer16BitAccess */
1651 /* skip val->storagePushConstant16 */
1652 /* skip val->storageInputOutput16 */
1653 }
1654
1655 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDevice16BitStorageFeatures * val)1656 vn_encode_VkPhysicalDevice16BitStorageFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
1657 {
1658 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
1659 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES });
1660 vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext_partial(enc, val->pNext);
1661 vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(enc, val);
1662 }
1663
1664 /* struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures chain */
1665
1666 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(const void * val)1667 vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(const void *val)
1668 {
1669 /* no known/supported struct */
1670 return vn_sizeof_simple_pointer(NULL);
1671 }
1672
1673 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1674 vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1675 {
1676 size_t size = 0;
1677 /* skip val->{sType,pNext} */
1678 size += vn_sizeof_VkBool32(&val->shaderSubgroupExtendedTypes);
1679 return size;
1680 }
1681
1682 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1683 vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1684 {
1685 size_t size = 0;
1686
1687 size += vn_sizeof_VkStructureType(&val->sType);
1688 size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(val->pNext);
1689 size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(val);
1690
1691 return size;
1692 }
1693
1694 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1695 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1696 {
1697 /* no known/supported struct */
1698 vn_encode_simple_pointer(enc, NULL);
1699 }
1700
1701 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1702 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1703 {
1704 /* skip val->{sType,pNext} */
1705 vn_encode_VkBool32(enc, &val->shaderSubgroupExtendedTypes);
1706 }
1707
1708 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1709 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1710 {
1711 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
1712 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES });
1713 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(enc, val->pNext);
1714 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, val);
1715 }
1716
1717 static inline void
vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_decoder * dec,const void * val)1718 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
1719 {
1720 /* no known/supported struct */
1721 if (vn_decode_simple_pointer(dec))
1722 assert(false);
1723 }
1724
1725 static inline void
vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1726 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1727 {
1728 /* skip val->{sType,pNext} */
1729 vn_decode_VkBool32(dec, &val->shaderSubgroupExtendedTypes);
1730 }
1731
1732 static inline void
vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1733 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1734 {
1735 VkStructureType stype;
1736 vn_decode_VkStructureType(dec, &stype);
1737 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
1738
1739 assert(val->sType == stype);
1740 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(dec, val->pNext);
1741 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(dec, val);
1742 }
1743
1744 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(const void * val)1745 vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(const void *val)
1746 {
1747 /* no known/supported struct */
1748 return vn_sizeof_simple_pointer(NULL);
1749 }
1750
1751 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1752 vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1753 {
1754 size_t size = 0;
1755 /* skip val->{sType,pNext} */
1756 /* skip val->shaderSubgroupExtendedTypes */
1757 return size;
1758 }
1759
1760 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1761 vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1762 {
1763 size_t size = 0;
1764
1765 size += vn_sizeof_VkStructureType(&val->sType);
1766 size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(val->pNext);
1767 size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(val);
1768
1769 return size;
1770 }
1771
1772 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)1773 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
1774 {
1775 /* no known/supported struct */
1776 vn_encode_simple_pointer(enc, NULL);
1777 }
1778
1779 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1780 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1781 {
1782 /* skip val->{sType,pNext} */
1783 /* skip val->shaderSubgroupExtendedTypes */
1784 }
1785
1786 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1787 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1788 {
1789 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
1790 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES });
1791 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(enc, val->pNext);
1792 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(enc, val);
1793 }
1794
1795 /* struct VkPhysicalDeviceSamplerYcbcrConversionFeatures chain */
1796
1797 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(const void * val)1798 vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(const void *val)
1799 {
1800 /* no known/supported struct */
1801 return vn_sizeof_simple_pointer(NULL);
1802 }
1803
1804 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1805 vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1806 {
1807 size_t size = 0;
1808 /* skip val->{sType,pNext} */
1809 size += vn_sizeof_VkBool32(&val->samplerYcbcrConversion);
1810 return size;
1811 }
1812
1813 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1814 vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1815 {
1816 size_t size = 0;
1817
1818 size += vn_sizeof_VkStructureType(&val->sType);
1819 size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(val->pNext);
1820 size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(val);
1821
1822 return size;
1823 }
1824
1825 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1826 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1827 {
1828 /* no known/supported struct */
1829 vn_encode_simple_pointer(enc, NULL);
1830 }
1831
1832 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1833 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1834 {
1835 /* skip val->{sType,pNext} */
1836 vn_encode_VkBool32(enc, &val->samplerYcbcrConversion);
1837 }
1838
1839 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1840 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1841 {
1842 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
1843 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES });
1844 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(enc, val->pNext);
1845 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, val);
1846 }
1847
1848 static inline void
vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_decoder * dec,const void * val)1849 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
1850 {
1851 /* no known/supported struct */
1852 if (vn_decode_simple_pointer(dec))
1853 assert(false);
1854 }
1855
1856 static inline void
vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1857 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1858 {
1859 /* skip val->{sType,pNext} */
1860 vn_decode_VkBool32(dec, &val->samplerYcbcrConversion);
1861 }
1862
1863 static inline void
vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1864 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1865 {
1866 VkStructureType stype;
1867 vn_decode_VkStructureType(dec, &stype);
1868 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
1869
1870 assert(val->sType == stype);
1871 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(dec, val->pNext);
1872 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(dec, val);
1873 }
1874
1875 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(const void * val)1876 vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(const void *val)
1877 {
1878 /* no known/supported struct */
1879 return vn_sizeof_simple_pointer(NULL);
1880 }
1881
1882 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1883 vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1884 {
1885 size_t size = 0;
1886 /* skip val->{sType,pNext} */
1887 /* skip val->samplerYcbcrConversion */
1888 return size;
1889 }
1890
1891 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial(const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1892 vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1893 {
1894 size_t size = 0;
1895
1896 size += vn_sizeof_VkStructureType(&val->sType);
1897 size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(val->pNext);
1898 size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(val);
1899
1900 return size;
1901 }
1902
1903 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)1904 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
1905 {
1906 /* no known/supported struct */
1907 vn_encode_simple_pointer(enc, NULL);
1908 }
1909
1910 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1911 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1912 {
1913 /* skip val->{sType,pNext} */
1914 /* skip val->samplerYcbcrConversion */
1915 }
1916
1917 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1918 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1919 {
1920 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
1921 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES });
1922 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(enc, val->pNext);
1923 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(enc, val);
1924 }
1925
1926 /* struct VkPhysicalDeviceProtectedMemoryFeatures chain */
1927
1928 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext(const void * val)1929 vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext(const void *val)
1930 {
1931 /* no known/supported struct */
1932 return vn_sizeof_simple_pointer(NULL);
1933 }
1934
1935 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self(const VkPhysicalDeviceProtectedMemoryFeatures * val)1936 vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self(const VkPhysicalDeviceProtectedMemoryFeatures *val)
1937 {
1938 size_t size = 0;
1939 /* skip val->{sType,pNext} */
1940 size += vn_sizeof_VkBool32(&val->protectedMemory);
1941 return size;
1942 }
1943
1944 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures * val)1945 vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures *val)
1946 {
1947 size_t size = 0;
1948
1949 size += vn_sizeof_VkStructureType(&val->sType);
1950 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext(val->pNext);
1951 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self(val);
1952
1953 return size;
1954 }
1955
1956 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1957 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1958 {
1959 /* no known/supported struct */
1960 vn_encode_simple_pointer(enc, NULL);
1961 }
1962
1963 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryFeatures * val)1964 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
1965 {
1966 /* skip val->{sType,pNext} */
1967 vn_encode_VkBool32(enc, &val->protectedMemory);
1968 }
1969
1970 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryFeatures * val)1971 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
1972 {
1973 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
1974 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES });
1975 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(enc, val->pNext);
1976 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, val);
1977 }
1978
1979 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_decoder * dec,const void * val)1980 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
1981 {
1982 /* no known/supported struct */
1983 if (vn_decode_simple_pointer(dec))
1984 assert(false);
1985 }
1986
1987 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryFeatures * val)1988 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryFeatures *val)
1989 {
1990 /* skip val->{sType,pNext} */
1991 vn_decode_VkBool32(dec, &val->protectedMemory);
1992 }
1993
1994 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryFeatures * val)1995 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryFeatures *val)
1996 {
1997 VkStructureType stype;
1998 vn_decode_VkStructureType(dec, &stype);
1999 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
2000
2001 assert(val->sType == stype);
2002 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(dec, val->pNext);
2003 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(dec, val);
2004 }
2005
2006 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(const void * val)2007 vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(const void *val)
2008 {
2009 /* no known/supported struct */
2010 return vn_sizeof_simple_pointer(NULL);
2011 }
2012
2013 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(const VkPhysicalDeviceProtectedMemoryFeatures * val)2014 vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(const VkPhysicalDeviceProtectedMemoryFeatures *val)
2015 {
2016 size_t size = 0;
2017 /* skip val->{sType,pNext} */
2018 /* skip val->protectedMemory */
2019 return size;
2020 }
2021
2022 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_partial(const VkPhysicalDeviceProtectedMemoryFeatures * val)2023 vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_partial(const VkPhysicalDeviceProtectedMemoryFeatures *val)
2024 {
2025 size_t size = 0;
2026
2027 size += vn_sizeof_VkStructureType(&val->sType);
2028 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(val->pNext);
2029 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(val);
2030
2031 return size;
2032 }
2033
2034 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)2035 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2036 {
2037 /* no known/supported struct */
2038 vn_encode_simple_pointer(enc, NULL);
2039 }
2040
2041 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryFeatures * val)2042 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
2043 {
2044 /* skip val->{sType,pNext} */
2045 /* skip val->protectedMemory */
2046 }
2047
2048 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryFeatures * val)2049 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
2050 {
2051 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
2052 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES });
2053 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(enc, val->pNext);
2054 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(enc, val);
2055 }
2056
2057 /* struct VkPhysicalDeviceShaderDrawParametersFeatures chain */
2058
2059 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(const void * val)2060 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(const void *val)
2061 {
2062 /* no known/supported struct */
2063 return vn_sizeof_simple_pointer(NULL);
2064 }
2065
2066 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self(const VkPhysicalDeviceShaderDrawParametersFeatures * val)2067 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2068 {
2069 size_t size = 0;
2070 /* skip val->{sType,pNext} */
2071 size += vn_sizeof_VkBool32(&val->shaderDrawParameters);
2072 return size;
2073 }
2074
2075 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures * val)2076 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2077 {
2078 size_t size = 0;
2079
2080 size += vn_sizeof_VkStructureType(&val->sType);
2081 size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(val->pNext);
2082 size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self(val);
2083
2084 return size;
2085 }
2086
2087 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2088 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2089 {
2090 /* no known/supported struct */
2091 vn_encode_simple_pointer(enc, NULL);
2092 }
2093
2094 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDrawParametersFeatures * val)2095 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2096 {
2097 /* skip val->{sType,pNext} */
2098 vn_encode_VkBool32(enc, &val->shaderDrawParameters);
2099 }
2100
2101 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDrawParametersFeatures * val)2102 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2103 {
2104 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
2105 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES });
2106 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(enc, val->pNext);
2107 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, val);
2108 }
2109
2110 static inline void
vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_decoder * dec,const void * val)2111 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
2112 {
2113 /* no known/supported struct */
2114 if (vn_decode_simple_pointer(dec))
2115 assert(false);
2116 }
2117
2118 static inline void
vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderDrawParametersFeatures * val)2119 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDrawParametersFeatures *val)
2120 {
2121 /* skip val->{sType,pNext} */
2122 vn_decode_VkBool32(dec, &val->shaderDrawParameters);
2123 }
2124
2125 static inline void
vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderDrawParametersFeatures * val)2126 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDrawParametersFeatures *val)
2127 {
2128 VkStructureType stype;
2129 vn_decode_VkStructureType(dec, &stype);
2130 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
2131
2132 assert(val->sType == stype);
2133 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(dec, val->pNext);
2134 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(dec, val);
2135 }
2136
2137 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(const void * val)2138 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(const void *val)
2139 {
2140 /* no known/supported struct */
2141 return vn_sizeof_simple_pointer(NULL);
2142 }
2143
2144 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(const VkPhysicalDeviceShaderDrawParametersFeatures * val)2145 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2146 {
2147 size_t size = 0;
2148 /* skip val->{sType,pNext} */
2149 /* skip val->shaderDrawParameters */
2150 return size;
2151 }
2152
2153 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_partial(const VkPhysicalDeviceShaderDrawParametersFeatures * val)2154 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_partial(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2155 {
2156 size_t size = 0;
2157
2158 size += vn_sizeof_VkStructureType(&val->sType);
2159 size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(val->pNext);
2160 size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(val);
2161
2162 return size;
2163 }
2164
2165 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)2166 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2167 {
2168 /* no known/supported struct */
2169 vn_encode_simple_pointer(enc, NULL);
2170 }
2171
2172 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDrawParametersFeatures * val)2173 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2174 {
2175 /* skip val->{sType,pNext} */
2176 /* skip val->shaderDrawParameters */
2177 }
2178
2179 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDrawParametersFeatures * val)2180 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2181 {
2182 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
2183 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES });
2184 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(enc, val->pNext);
2185 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(enc, val);
2186 }
2187
2188 /* struct VkPhysicalDeviceShaderFloat16Int8Features chain */
2189
2190 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext(const void * val)2191 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext(const void *val)
2192 {
2193 /* no known/supported struct */
2194 return vn_sizeof_simple_pointer(NULL);
2195 }
2196
2197 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self(const VkPhysicalDeviceShaderFloat16Int8Features * val)2198 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self(const VkPhysicalDeviceShaderFloat16Int8Features *val)
2199 {
2200 size_t size = 0;
2201 /* skip val->{sType,pNext} */
2202 size += vn_sizeof_VkBool32(&val->shaderFloat16);
2203 size += vn_sizeof_VkBool32(&val->shaderInt8);
2204 return size;
2205 }
2206
2207 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features * val)2208 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features *val)
2209 {
2210 size_t size = 0;
2211
2212 size += vn_sizeof_VkStructureType(&val->sType);
2213 size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext(val->pNext);
2214 size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self(val);
2215
2216 return size;
2217 }
2218
2219 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_encoder * enc,const void * val)2220 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_encoder *enc, const void *val)
2221 {
2222 /* no known/supported struct */
2223 vn_encode_simple_pointer(enc, NULL);
2224 }
2225
2226 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderFloat16Int8Features * val)2227 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
2228 {
2229 /* skip val->{sType,pNext} */
2230 vn_encode_VkBool32(enc, &val->shaderFloat16);
2231 vn_encode_VkBool32(enc, &val->shaderInt8);
2232 }
2233
2234 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderFloat16Int8Features * val)2235 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
2236 {
2237 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
2238 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES });
2239 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(enc, val->pNext);
2240 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, val);
2241 }
2242
2243 static inline void
vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_decoder * dec,const void * val)2244 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_decoder *dec, const void *val)
2245 {
2246 /* no known/supported struct */
2247 if (vn_decode_simple_pointer(dec))
2248 assert(false);
2249 }
2250
2251 static inline void
vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderFloat16Int8Features * val)2252 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderFloat16Int8Features *val)
2253 {
2254 /* skip val->{sType,pNext} */
2255 vn_decode_VkBool32(dec, &val->shaderFloat16);
2256 vn_decode_VkBool32(dec, &val->shaderInt8);
2257 }
2258
2259 static inline void
vn_decode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderFloat16Int8Features * val)2260 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderFloat16Int8Features *val)
2261 {
2262 VkStructureType stype;
2263 vn_decode_VkStructureType(dec, &stype);
2264 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
2265
2266 assert(val->sType == stype);
2267 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(dec, val->pNext);
2268 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(dec, val);
2269 }
2270
2271 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(const void * val)2272 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(const void *val)
2273 {
2274 /* no known/supported struct */
2275 return vn_sizeof_simple_pointer(NULL);
2276 }
2277
2278 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(const VkPhysicalDeviceShaderFloat16Int8Features * val)2279 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(const VkPhysicalDeviceShaderFloat16Int8Features *val)
2280 {
2281 size_t size = 0;
2282 /* skip val->{sType,pNext} */
2283 /* skip val->shaderFloat16 */
2284 /* skip val->shaderInt8 */
2285 return size;
2286 }
2287
2288 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_partial(const VkPhysicalDeviceShaderFloat16Int8Features * val)2289 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_partial(const VkPhysicalDeviceShaderFloat16Int8Features *val)
2290 {
2291 size_t size = 0;
2292
2293 size += vn_sizeof_VkStructureType(&val->sType);
2294 size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(val->pNext);
2295 size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(val);
2296
2297 return size;
2298 }
2299
2300 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)2301 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2302 {
2303 /* no known/supported struct */
2304 vn_encode_simple_pointer(enc, NULL);
2305 }
2306
2307 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderFloat16Int8Features * val)2308 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
2309 {
2310 /* skip val->{sType,pNext} */
2311 /* skip val->shaderFloat16 */
2312 /* skip val->shaderInt8 */
2313 }
2314
2315 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderFloat16Int8Features * val)2316 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
2317 {
2318 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
2319 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES });
2320 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(enc, val->pNext);
2321 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(enc, val);
2322 }
2323
2324 /* struct VkPhysicalDeviceHostQueryResetFeatures chain */
2325
2326 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext(const void * val)2327 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext(const void *val)
2328 {
2329 /* no known/supported struct */
2330 return vn_sizeof_simple_pointer(NULL);
2331 }
2332
2333 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self(const VkPhysicalDeviceHostQueryResetFeatures * val)2334 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self(const VkPhysicalDeviceHostQueryResetFeatures *val)
2335 {
2336 size_t size = 0;
2337 /* skip val->{sType,pNext} */
2338 size += vn_sizeof_VkBool32(&val->hostQueryReset);
2339 return size;
2340 }
2341
2342 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures * val)2343 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures *val)
2344 {
2345 size_t size = 0;
2346
2347 size += vn_sizeof_VkStructureType(&val->sType);
2348 size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext(val->pNext);
2349 size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self(val);
2350
2351 return size;
2352 }
2353
2354 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2355 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2356 {
2357 /* no known/supported struct */
2358 vn_encode_simple_pointer(enc, NULL);
2359 }
2360
2361 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceHostQueryResetFeatures * val)2362 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
2363 {
2364 /* skip val->{sType,pNext} */
2365 vn_encode_VkBool32(enc, &val->hostQueryReset);
2366 }
2367
2368 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceHostQueryResetFeatures * val)2369 vn_encode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
2370 {
2371 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
2372 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES });
2373 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(enc, val->pNext);
2374 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, val);
2375 }
2376
2377 static inline void
vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_decoder * dec,const void * val)2378 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
2379 {
2380 /* no known/supported struct */
2381 if (vn_decode_simple_pointer(dec))
2382 assert(false);
2383 }
2384
2385 static inline void
vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceHostQueryResetFeatures * val)2386 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceHostQueryResetFeatures *val)
2387 {
2388 /* skip val->{sType,pNext} */
2389 vn_decode_VkBool32(dec, &val->hostQueryReset);
2390 }
2391
2392 static inline void
vn_decode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceHostQueryResetFeatures * val)2393 vn_decode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceHostQueryResetFeatures *val)
2394 {
2395 VkStructureType stype;
2396 vn_decode_VkStructureType(dec, &stype);
2397 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
2398
2399 assert(val->sType == stype);
2400 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext(dec, val->pNext);
2401 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(dec, val);
2402 }
2403
2404 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(const void * val)2405 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(const void *val)
2406 {
2407 /* no known/supported struct */
2408 return vn_sizeof_simple_pointer(NULL);
2409 }
2410
2411 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial(const VkPhysicalDeviceHostQueryResetFeatures * val)2412 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial(const VkPhysicalDeviceHostQueryResetFeatures *val)
2413 {
2414 size_t size = 0;
2415 /* skip val->{sType,pNext} */
2416 /* skip val->hostQueryReset */
2417 return size;
2418 }
2419
2420 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_partial(const VkPhysicalDeviceHostQueryResetFeatures * val)2421 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_partial(const VkPhysicalDeviceHostQueryResetFeatures *val)
2422 {
2423 size_t size = 0;
2424
2425 size += vn_sizeof_VkStructureType(&val->sType);
2426 size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(val->pNext);
2427 size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial(val);
2428
2429 return size;
2430 }
2431
2432 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)2433 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2434 {
2435 /* no known/supported struct */
2436 vn_encode_simple_pointer(enc, NULL);
2437 }
2438
2439 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceHostQueryResetFeatures * val)2440 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
2441 {
2442 /* skip val->{sType,pNext} */
2443 /* skip val->hostQueryReset */
2444 }
2445
2446 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceHostQueryResetFeatures * val)2447 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
2448 {
2449 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
2450 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES });
2451 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(enc, val->pNext);
2452 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(enc, val);
2453 }
2454
2455 /* struct VkPhysicalDeviceDescriptorIndexingFeatures chain */
2456
2457 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(const void * val)2458 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(const void *val)
2459 {
2460 /* no known/supported struct */
2461 return vn_sizeof_simple_pointer(NULL);
2462 }
2463
2464 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self(const VkPhysicalDeviceDescriptorIndexingFeatures * val)2465 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2466 {
2467 size_t size = 0;
2468 /* skip val->{sType,pNext} */
2469 size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayDynamicIndexing);
2470 size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayDynamicIndexing);
2471 size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayDynamicIndexing);
2472 size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexing);
2473 size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexing);
2474 size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexing);
2475 size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexing);
2476 size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexing);
2477 size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayNonUniformIndexing);
2478 size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayNonUniformIndexing);
2479 size += vn_sizeof_VkBool32(&val->descriptorBindingUniformBufferUpdateAfterBind);
2480 size += vn_sizeof_VkBool32(&val->descriptorBindingSampledImageUpdateAfterBind);
2481 size += vn_sizeof_VkBool32(&val->descriptorBindingStorageImageUpdateAfterBind);
2482 size += vn_sizeof_VkBool32(&val->descriptorBindingStorageBufferUpdateAfterBind);
2483 size += vn_sizeof_VkBool32(&val->descriptorBindingUniformTexelBufferUpdateAfterBind);
2484 size += vn_sizeof_VkBool32(&val->descriptorBindingStorageTexelBufferUpdateAfterBind);
2485 size += vn_sizeof_VkBool32(&val->descriptorBindingUpdateUnusedWhilePending);
2486 size += vn_sizeof_VkBool32(&val->descriptorBindingPartiallyBound);
2487 size += vn_sizeof_VkBool32(&val->descriptorBindingVariableDescriptorCount);
2488 size += vn_sizeof_VkBool32(&val->runtimeDescriptorArray);
2489 return size;
2490 }
2491
2492 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures * val)2493 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2494 {
2495 size_t size = 0;
2496
2497 size += vn_sizeof_VkStructureType(&val->sType);
2498 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(val->pNext);
2499 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self(val);
2500
2501 return size;
2502 }
2503
2504 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2505 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2506 {
2507 /* no known/supported struct */
2508 vn_encode_simple_pointer(enc, NULL);
2509 }
2510
2511 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingFeatures * val)2512 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2513 {
2514 /* skip val->{sType,pNext} */
2515 vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayDynamicIndexing);
2516 vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayDynamicIndexing);
2517 vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayDynamicIndexing);
2518 vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayNonUniformIndexing);
2519 vn_encode_VkBool32(enc, &val->shaderSampledImageArrayNonUniformIndexing);
2520 vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayNonUniformIndexing);
2521 vn_encode_VkBool32(enc, &val->shaderStorageImageArrayNonUniformIndexing);
2522 vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayNonUniformIndexing);
2523 vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
2524 vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
2525 vn_encode_VkBool32(enc, &val->descriptorBindingUniformBufferUpdateAfterBind);
2526 vn_encode_VkBool32(enc, &val->descriptorBindingSampledImageUpdateAfterBind);
2527 vn_encode_VkBool32(enc, &val->descriptorBindingStorageImageUpdateAfterBind);
2528 vn_encode_VkBool32(enc, &val->descriptorBindingStorageBufferUpdateAfterBind);
2529 vn_encode_VkBool32(enc, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
2530 vn_encode_VkBool32(enc, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
2531 vn_encode_VkBool32(enc, &val->descriptorBindingUpdateUnusedWhilePending);
2532 vn_encode_VkBool32(enc, &val->descriptorBindingPartiallyBound);
2533 vn_encode_VkBool32(enc, &val->descriptorBindingVariableDescriptorCount);
2534 vn_encode_VkBool32(enc, &val->runtimeDescriptorArray);
2535 }
2536
2537 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingFeatures * val)2538 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2539 {
2540 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
2541 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES });
2542 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(enc, val->pNext);
2543 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, val);
2544 }
2545
2546 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_decoder * dec,const void * val)2547 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
2548 {
2549 /* no known/supported struct */
2550 if (vn_decode_simple_pointer(dec))
2551 assert(false);
2552 }
2553
2554 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingFeatures * val)2555 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingFeatures *val)
2556 {
2557 /* skip val->{sType,pNext} */
2558 vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayDynamicIndexing);
2559 vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayDynamicIndexing);
2560 vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayDynamicIndexing);
2561 vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexing);
2562 vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexing);
2563 vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexing);
2564 vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexing);
2565 vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexing);
2566 vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
2567 vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
2568 vn_decode_VkBool32(dec, &val->descriptorBindingUniformBufferUpdateAfterBind);
2569 vn_decode_VkBool32(dec, &val->descriptorBindingSampledImageUpdateAfterBind);
2570 vn_decode_VkBool32(dec, &val->descriptorBindingStorageImageUpdateAfterBind);
2571 vn_decode_VkBool32(dec, &val->descriptorBindingStorageBufferUpdateAfterBind);
2572 vn_decode_VkBool32(dec, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
2573 vn_decode_VkBool32(dec, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
2574 vn_decode_VkBool32(dec, &val->descriptorBindingUpdateUnusedWhilePending);
2575 vn_decode_VkBool32(dec, &val->descriptorBindingPartiallyBound);
2576 vn_decode_VkBool32(dec, &val->descriptorBindingVariableDescriptorCount);
2577 vn_decode_VkBool32(dec, &val->runtimeDescriptorArray);
2578 }
2579
2580 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingFeatures * val)2581 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingFeatures *val)
2582 {
2583 VkStructureType stype;
2584 vn_decode_VkStructureType(dec, &stype);
2585 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
2586
2587 assert(val->sType == stype);
2588 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(dec, val->pNext);
2589 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(dec, val);
2590 }
2591
2592 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(const void * val)2593 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(const void *val)
2594 {
2595 /* no known/supported struct */
2596 return vn_sizeof_simple_pointer(NULL);
2597 }
2598
2599 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(const VkPhysicalDeviceDescriptorIndexingFeatures * val)2600 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2601 {
2602 size_t size = 0;
2603 /* skip val->{sType,pNext} */
2604 /* skip val->shaderInputAttachmentArrayDynamicIndexing */
2605 /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
2606 /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
2607 /* skip val->shaderUniformBufferArrayNonUniformIndexing */
2608 /* skip val->shaderSampledImageArrayNonUniformIndexing */
2609 /* skip val->shaderStorageBufferArrayNonUniformIndexing */
2610 /* skip val->shaderStorageImageArrayNonUniformIndexing */
2611 /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
2612 /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
2613 /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
2614 /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
2615 /* skip val->descriptorBindingSampledImageUpdateAfterBind */
2616 /* skip val->descriptorBindingStorageImageUpdateAfterBind */
2617 /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
2618 /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
2619 /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
2620 /* skip val->descriptorBindingUpdateUnusedWhilePending */
2621 /* skip val->descriptorBindingPartiallyBound */
2622 /* skip val->descriptorBindingVariableDescriptorCount */
2623 /* skip val->runtimeDescriptorArray */
2624 return size;
2625 }
2626
2627 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_partial(const VkPhysicalDeviceDescriptorIndexingFeatures * val)2628 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_partial(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2629 {
2630 size_t size = 0;
2631
2632 size += vn_sizeof_VkStructureType(&val->sType);
2633 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(val->pNext);
2634 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(val);
2635
2636 return size;
2637 }
2638
2639 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)2640 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2641 {
2642 /* no known/supported struct */
2643 vn_encode_simple_pointer(enc, NULL);
2644 }
2645
2646 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingFeatures * val)2647 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2648 {
2649 /* skip val->{sType,pNext} */
2650 /* skip val->shaderInputAttachmentArrayDynamicIndexing */
2651 /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
2652 /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
2653 /* skip val->shaderUniformBufferArrayNonUniformIndexing */
2654 /* skip val->shaderSampledImageArrayNonUniformIndexing */
2655 /* skip val->shaderStorageBufferArrayNonUniformIndexing */
2656 /* skip val->shaderStorageImageArrayNonUniformIndexing */
2657 /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
2658 /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
2659 /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
2660 /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
2661 /* skip val->descriptorBindingSampledImageUpdateAfterBind */
2662 /* skip val->descriptorBindingStorageImageUpdateAfterBind */
2663 /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
2664 /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
2665 /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
2666 /* skip val->descriptorBindingUpdateUnusedWhilePending */
2667 /* skip val->descriptorBindingPartiallyBound */
2668 /* skip val->descriptorBindingVariableDescriptorCount */
2669 /* skip val->runtimeDescriptorArray */
2670 }
2671
2672 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingFeatures * val)2673 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2674 {
2675 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
2676 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES });
2677 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(enc, val->pNext);
2678 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(enc, val);
2679 }
2680
2681 /* struct VkPhysicalDeviceTimelineSemaphoreFeatures chain */
2682
2683 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(const void * val)2684 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(const void *val)
2685 {
2686 /* no known/supported struct */
2687 return vn_sizeof_simple_pointer(NULL);
2688 }
2689
2690 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self(const VkPhysicalDeviceTimelineSemaphoreFeatures * val)2691 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2692 {
2693 size_t size = 0;
2694 /* skip val->{sType,pNext} */
2695 size += vn_sizeof_VkBool32(&val->timelineSemaphore);
2696 return size;
2697 }
2698
2699 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures * val)2700 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2701 {
2702 size_t size = 0;
2703
2704 size += vn_sizeof_VkStructureType(&val->sType);
2705 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(val->pNext);
2706 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self(val);
2707
2708 return size;
2709 }
2710
2711 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2712 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2713 {
2714 /* no known/supported struct */
2715 vn_encode_simple_pointer(enc, NULL);
2716 }
2717
2718 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreFeatures * val)2719 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2720 {
2721 /* skip val->{sType,pNext} */
2722 vn_encode_VkBool32(enc, &val->timelineSemaphore);
2723 }
2724
2725 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreFeatures * val)2726 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2727 {
2728 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
2729 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES });
2730 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(enc, val->pNext);
2731 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, val);
2732 }
2733
2734 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_decoder * dec,const void * val)2735 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
2736 {
2737 /* no known/supported struct */
2738 if (vn_decode_simple_pointer(dec))
2739 assert(false);
2740 }
2741
2742 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreFeatures * val)2743 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2744 {
2745 /* skip val->{sType,pNext} */
2746 vn_decode_VkBool32(dec, &val->timelineSemaphore);
2747 }
2748
2749 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreFeatures * val)2750 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2751 {
2752 VkStructureType stype;
2753 vn_decode_VkStructureType(dec, &stype);
2754 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
2755
2756 assert(val->sType == stype);
2757 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(dec, val->pNext);
2758 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(dec, val);
2759 }
2760
2761 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(const void * val)2762 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(const void *val)
2763 {
2764 /* no known/supported struct */
2765 return vn_sizeof_simple_pointer(NULL);
2766 }
2767
2768 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures * val)2769 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2770 {
2771 size_t size = 0;
2772 /* skip val->{sType,pNext} */
2773 /* skip val->timelineSemaphore */
2774 return size;
2775 }
2776
2777 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures * val)2778 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2779 {
2780 size_t size = 0;
2781
2782 size += vn_sizeof_VkStructureType(&val->sType);
2783 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(val->pNext);
2784 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(val);
2785
2786 return size;
2787 }
2788
2789 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)2790 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2791 {
2792 /* no known/supported struct */
2793 vn_encode_simple_pointer(enc, NULL);
2794 }
2795
2796 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreFeatures * val)2797 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2798 {
2799 /* skip val->{sType,pNext} */
2800 /* skip val->timelineSemaphore */
2801 }
2802
2803 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreFeatures * val)2804 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2805 {
2806 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
2807 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES });
2808 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(enc, val->pNext);
2809 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(enc, val);
2810 }
2811
2812 /* struct VkPhysicalDevice8BitStorageFeatures chain */
2813
2814 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext(const void * val)2815 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext(const void *val)
2816 {
2817 /* no known/supported struct */
2818 return vn_sizeof_simple_pointer(NULL);
2819 }
2820
2821 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self(const VkPhysicalDevice8BitStorageFeatures * val)2822 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self(const VkPhysicalDevice8BitStorageFeatures *val)
2823 {
2824 size_t size = 0;
2825 /* skip val->{sType,pNext} */
2826 size += vn_sizeof_VkBool32(&val->storageBuffer8BitAccess);
2827 size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer8BitAccess);
2828 size += vn_sizeof_VkBool32(&val->storagePushConstant8);
2829 return size;
2830 }
2831
2832 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures * val)2833 vn_sizeof_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures *val)
2834 {
2835 size_t size = 0;
2836
2837 size += vn_sizeof_VkStructureType(&val->sType);
2838 size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext(val->pNext);
2839 size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self(val);
2840
2841 return size;
2842 }
2843
2844 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2845 vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2846 {
2847 /* no known/supported struct */
2848 vn_encode_simple_pointer(enc, NULL);
2849 }
2850
2851 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDevice8BitStorageFeatures * val)2852 vn_encode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
2853 {
2854 /* skip val->{sType,pNext} */
2855 vn_encode_VkBool32(enc, &val->storageBuffer8BitAccess);
2856 vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer8BitAccess);
2857 vn_encode_VkBool32(enc, &val->storagePushConstant8);
2858 }
2859
2860 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_encoder * enc,const VkPhysicalDevice8BitStorageFeatures * val)2861 vn_encode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
2862 {
2863 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
2864 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES });
2865 vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(enc, val->pNext);
2866 vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, val);
2867 }
2868
2869 static inline void
vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_decoder * dec,const void * val)2870 vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
2871 {
2872 /* no known/supported struct */
2873 if (vn_decode_simple_pointer(dec))
2874 assert(false);
2875 }
2876
2877 static inline void
vn_decode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDevice8BitStorageFeatures * val)2878 vn_decode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDevice8BitStorageFeatures *val)
2879 {
2880 /* skip val->{sType,pNext} */
2881 vn_decode_VkBool32(dec, &val->storageBuffer8BitAccess);
2882 vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer8BitAccess);
2883 vn_decode_VkBool32(dec, &val->storagePushConstant8);
2884 }
2885
2886 static inline void
vn_decode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_decoder * dec,VkPhysicalDevice8BitStorageFeatures * val)2887 vn_decode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_decoder *dec, VkPhysicalDevice8BitStorageFeatures *val)
2888 {
2889 VkStructureType stype;
2890 vn_decode_VkStructureType(dec, &stype);
2891 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
2892
2893 assert(val->sType == stype);
2894 vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext(dec, val->pNext);
2895 vn_decode_VkPhysicalDevice8BitStorageFeatures_self(dec, val);
2896 }
2897
2898 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext_partial(const void * val)2899 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext_partial(const void *val)
2900 {
2901 /* no known/supported struct */
2902 return vn_sizeof_simple_pointer(NULL);
2903 }
2904
2905 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial(const VkPhysicalDevice8BitStorageFeatures * val)2906 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial(const VkPhysicalDevice8BitStorageFeatures *val)
2907 {
2908 size_t size = 0;
2909 /* skip val->{sType,pNext} */
2910 /* skip val->storageBuffer8BitAccess */
2911 /* skip val->uniformAndStorageBuffer8BitAccess */
2912 /* skip val->storagePushConstant8 */
2913 return size;
2914 }
2915
2916 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_partial(const VkPhysicalDevice8BitStorageFeatures * val)2917 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_partial(const VkPhysicalDevice8BitStorageFeatures *val)
2918 {
2919 size_t size = 0;
2920
2921 size += vn_sizeof_VkStructureType(&val->sType);
2922 size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext_partial(val->pNext);
2923 size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial(val);
2924
2925 return size;
2926 }
2927
2928 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)2929 vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2930 {
2931 /* no known/supported struct */
2932 vn_encode_simple_pointer(enc, NULL);
2933 }
2934
2935 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevice8BitStorageFeatures * val)2936 vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
2937 {
2938 /* skip val->{sType,pNext} */
2939 /* skip val->storageBuffer8BitAccess */
2940 /* skip val->uniformAndStorageBuffer8BitAccess */
2941 /* skip val->storagePushConstant8 */
2942 }
2943
2944 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDevice8BitStorageFeatures * val)2945 vn_encode_VkPhysicalDevice8BitStorageFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
2946 {
2947 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
2948 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES });
2949 vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext_partial(enc, val->pNext);
2950 vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(enc, val);
2951 }
2952
2953 /* struct VkPhysicalDeviceVulkanMemoryModelFeatures chain */
2954
2955 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(const void * val)2956 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(const void *val)
2957 {
2958 /* no known/supported struct */
2959 return vn_sizeof_simple_pointer(NULL);
2960 }
2961
2962 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self(const VkPhysicalDeviceVulkanMemoryModelFeatures * val)2963 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
2964 {
2965 size_t size = 0;
2966 /* skip val->{sType,pNext} */
2967 size += vn_sizeof_VkBool32(&val->vulkanMemoryModel);
2968 size += vn_sizeof_VkBool32(&val->vulkanMemoryModelDeviceScope);
2969 size += vn_sizeof_VkBool32(&val->vulkanMemoryModelAvailabilityVisibilityChains);
2970 return size;
2971 }
2972
2973 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures * val)2974 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
2975 {
2976 size_t size = 0;
2977
2978 size += vn_sizeof_VkStructureType(&val->sType);
2979 size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(val->pNext);
2980 size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self(val);
2981
2982 return size;
2983 }
2984
2985 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2986 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2987 {
2988 /* no known/supported struct */
2989 vn_encode_simple_pointer(enc, NULL);
2990 }
2991
2992 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkanMemoryModelFeatures * val)2993 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
2994 {
2995 /* skip val->{sType,pNext} */
2996 vn_encode_VkBool32(enc, &val->vulkanMemoryModel);
2997 vn_encode_VkBool32(enc, &val->vulkanMemoryModelDeviceScope);
2998 vn_encode_VkBool32(enc, &val->vulkanMemoryModelAvailabilityVisibilityChains);
2999 }
3000
3001 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3002 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3003 {
3004 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
3005 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES });
3006 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(enc, val->pNext);
3007 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, val);
3008 }
3009
3010 static inline void
vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3011 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3012 {
3013 /* no known/supported struct */
3014 if (vn_decode_simple_pointer(dec))
3015 assert(false);
3016 }
3017
3018 static inline void
vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkanMemoryModelFeatures * val)3019 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3020 {
3021 /* skip val->{sType,pNext} */
3022 vn_decode_VkBool32(dec, &val->vulkanMemoryModel);
3023 vn_decode_VkBool32(dec, &val->vulkanMemoryModelDeviceScope);
3024 vn_decode_VkBool32(dec, &val->vulkanMemoryModelAvailabilityVisibilityChains);
3025 }
3026
3027 static inline void
vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkanMemoryModelFeatures * val)3028 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3029 {
3030 VkStructureType stype;
3031 vn_decode_VkStructureType(dec, &stype);
3032 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
3033
3034 assert(val->sType == stype);
3035 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(dec, val->pNext);
3036 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(dec, val);
3037 }
3038
3039 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(const void * val)3040 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(const void *val)
3041 {
3042 /* no known/supported struct */
3043 return vn_sizeof_simple_pointer(NULL);
3044 }
3045
3046 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3047 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3048 {
3049 size_t size = 0;
3050 /* skip val->{sType,pNext} */
3051 /* skip val->vulkanMemoryModel */
3052 /* skip val->vulkanMemoryModelDeviceScope */
3053 /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
3054 return size;
3055 }
3056
3057 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3058 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3059 {
3060 size_t size = 0;
3061
3062 size += vn_sizeof_VkStructureType(&val->sType);
3063 size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(val->pNext);
3064 size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(val);
3065
3066 return size;
3067 }
3068
3069 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)3070 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3071 {
3072 /* no known/supported struct */
3073 vn_encode_simple_pointer(enc, NULL);
3074 }
3075
3076 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3077 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3078 {
3079 /* skip val->{sType,pNext} */
3080 /* skip val->vulkanMemoryModel */
3081 /* skip val->vulkanMemoryModelDeviceScope */
3082 /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
3083 }
3084
3085 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3086 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3087 {
3088 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
3089 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES });
3090 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(enc, val->pNext);
3091 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(enc, val);
3092 }
3093
3094 /* struct VkPhysicalDeviceShaderAtomicInt64Features chain */
3095
3096 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext(const void * val)3097 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext(const void *val)
3098 {
3099 /* no known/supported struct */
3100 return vn_sizeof_simple_pointer(NULL);
3101 }
3102
3103 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self(const VkPhysicalDeviceShaderAtomicInt64Features * val)3104 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self(const VkPhysicalDeviceShaderAtomicInt64Features *val)
3105 {
3106 size_t size = 0;
3107 /* skip val->{sType,pNext} */
3108 size += vn_sizeof_VkBool32(&val->shaderBufferInt64Atomics);
3109 size += vn_sizeof_VkBool32(&val->shaderSharedInt64Atomics);
3110 return size;
3111 }
3112
3113 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features * val)3114 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features *val)
3115 {
3116 size_t size = 0;
3117
3118 size += vn_sizeof_VkStructureType(&val->sType);
3119 size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext(val->pNext);
3120 size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self(val);
3121
3122 return size;
3123 }
3124
3125 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_encoder * enc,const void * val)3126 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_encoder *enc, const void *val)
3127 {
3128 /* no known/supported struct */
3129 vn_encode_simple_pointer(enc, NULL);
3130 }
3131
3132 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderAtomicInt64Features * val)3133 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
3134 {
3135 /* skip val->{sType,pNext} */
3136 vn_encode_VkBool32(enc, &val->shaderBufferInt64Atomics);
3137 vn_encode_VkBool32(enc, &val->shaderSharedInt64Atomics);
3138 }
3139
3140 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderAtomicInt64Features * val)3141 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
3142 {
3143 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
3144 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES });
3145 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(enc, val->pNext);
3146 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, val);
3147 }
3148
3149 static inline void
vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_decoder * dec,const void * val)3150 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_decoder *dec, const void *val)
3151 {
3152 /* no known/supported struct */
3153 if (vn_decode_simple_pointer(dec))
3154 assert(false);
3155 }
3156
3157 static inline void
vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderAtomicInt64Features * val)3158 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderAtomicInt64Features *val)
3159 {
3160 /* skip val->{sType,pNext} */
3161 vn_decode_VkBool32(dec, &val->shaderBufferInt64Atomics);
3162 vn_decode_VkBool32(dec, &val->shaderSharedInt64Atomics);
3163 }
3164
3165 static inline void
vn_decode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderAtomicInt64Features * val)3166 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderAtomicInt64Features *val)
3167 {
3168 VkStructureType stype;
3169 vn_decode_VkStructureType(dec, &stype);
3170 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
3171
3172 assert(val->sType == stype);
3173 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(dec, val->pNext);
3174 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(dec, val);
3175 }
3176
3177 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(const void * val)3178 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(const void *val)
3179 {
3180 /* no known/supported struct */
3181 return vn_sizeof_simple_pointer(NULL);
3182 }
3183
3184 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(const VkPhysicalDeviceShaderAtomicInt64Features * val)3185 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(const VkPhysicalDeviceShaderAtomicInt64Features *val)
3186 {
3187 size_t size = 0;
3188 /* skip val->{sType,pNext} */
3189 /* skip val->shaderBufferInt64Atomics */
3190 /* skip val->shaderSharedInt64Atomics */
3191 return size;
3192 }
3193
3194 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_partial(const VkPhysicalDeviceShaderAtomicInt64Features * val)3195 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_partial(const VkPhysicalDeviceShaderAtomicInt64Features *val)
3196 {
3197 size_t size = 0;
3198
3199 size += vn_sizeof_VkStructureType(&val->sType);
3200 size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(val->pNext);
3201 size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(val);
3202
3203 return size;
3204 }
3205
3206 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)3207 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3208 {
3209 /* no known/supported struct */
3210 vn_encode_simple_pointer(enc, NULL);
3211 }
3212
3213 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderAtomicInt64Features * val)3214 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
3215 {
3216 /* skip val->{sType,pNext} */
3217 /* skip val->shaderBufferInt64Atomics */
3218 /* skip val->shaderSharedInt64Atomics */
3219 }
3220
3221 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderAtomicInt64Features * val)3222 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
3223 {
3224 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
3225 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES });
3226 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(enc, val->pNext);
3227 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(enc, val);
3228 }
3229
3230 /* struct VkPhysicalDeviceTransformFeedbackFeaturesEXT chain */
3231
3232 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(const void * val)3233 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(const void *val)
3234 {
3235 /* no known/supported struct */
3236 return vn_sizeof_simple_pointer(NULL);
3237 }
3238
3239 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3240 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3241 {
3242 size_t size = 0;
3243 /* skip val->{sType,pNext} */
3244 size += vn_sizeof_VkBool32(&val->transformFeedback);
3245 size += vn_sizeof_VkBool32(&val->geometryStreams);
3246 return size;
3247 }
3248
3249 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3250 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3251 {
3252 size_t size = 0;
3253
3254 size += vn_sizeof_VkStructureType(&val->sType);
3255 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(val->pNext);
3256 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(val);
3257
3258 return size;
3259 }
3260
3261 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)3262 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
3263 {
3264 /* no known/supported struct */
3265 vn_encode_simple_pointer(enc, NULL);
3266 }
3267
3268 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3269 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3270 {
3271 /* skip val->{sType,pNext} */
3272 vn_encode_VkBool32(enc, &val->transformFeedback);
3273 vn_encode_VkBool32(enc, &val->geometryStreams);
3274 }
3275
3276 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3277 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3278 {
3279 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
3280 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT });
3281 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(enc, val->pNext);
3282 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, val);
3283 }
3284
3285 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)3286 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
3287 {
3288 /* no known/supported struct */
3289 if (vn_decode_simple_pointer(dec))
3290 assert(false);
3291 }
3292
3293 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3294 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3295 {
3296 /* skip val->{sType,pNext} */
3297 vn_decode_VkBool32(dec, &val->transformFeedback);
3298 vn_decode_VkBool32(dec, &val->geometryStreams);
3299 }
3300
3301 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3302 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3303 {
3304 VkStructureType stype;
3305 vn_decode_VkStructureType(dec, &stype);
3306 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
3307
3308 assert(val->sType == stype);
3309 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(dec, val->pNext);
3310 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(dec, val);
3311 }
3312
3313 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(const void * val)3314 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(const void *val)
3315 {
3316 /* no known/supported struct */
3317 return vn_sizeof_simple_pointer(NULL);
3318 }
3319
3320 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3321 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3322 {
3323 size_t size = 0;
3324 /* skip val->{sType,pNext} */
3325 /* skip val->transformFeedback */
3326 /* skip val->geometryStreams */
3327 return size;
3328 }
3329
3330 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3331 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3332 {
3333 size_t size = 0;
3334
3335 size += vn_sizeof_VkStructureType(&val->sType);
3336 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(val->pNext);
3337 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(val);
3338
3339 return size;
3340 }
3341
3342 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)3343 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3344 {
3345 /* no known/supported struct */
3346 vn_encode_simple_pointer(enc, NULL);
3347 }
3348
3349 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3350 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3351 {
3352 /* skip val->{sType,pNext} */
3353 /* skip val->transformFeedback */
3354 /* skip val->geometryStreams */
3355 }
3356
3357 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3358 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3359 {
3360 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
3361 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT });
3362 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(enc, val->pNext);
3363 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(enc, val);
3364 }
3365
3366 /* struct VkPhysicalDeviceScalarBlockLayoutFeatures chain */
3367
3368 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(const void * val)3369 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(const void *val)
3370 {
3371 /* no known/supported struct */
3372 return vn_sizeof_simple_pointer(NULL);
3373 }
3374
3375 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self(const VkPhysicalDeviceScalarBlockLayoutFeatures * val)3376 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3377 {
3378 size_t size = 0;
3379 /* skip val->{sType,pNext} */
3380 size += vn_sizeof_VkBool32(&val->scalarBlockLayout);
3381 return size;
3382 }
3383
3384 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures * val)3385 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3386 {
3387 size_t size = 0;
3388
3389 size += vn_sizeof_VkStructureType(&val->sType);
3390 size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(val->pNext);
3391 size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self(val);
3392
3393 return size;
3394 }
3395
3396 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_encoder * enc,const void * val)3397 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
3398 {
3399 /* no known/supported struct */
3400 vn_encode_simple_pointer(enc, NULL);
3401 }
3402
3403 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceScalarBlockLayoutFeatures * val)3404 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3405 {
3406 /* skip val->{sType,pNext} */
3407 vn_encode_VkBool32(enc, &val->scalarBlockLayout);
3408 }
3409
3410 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceScalarBlockLayoutFeatures * val)3411 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3412 {
3413 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
3414 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES });
3415 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(enc, val->pNext);
3416 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, val);
3417 }
3418
3419 static inline void
vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3420 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3421 {
3422 /* no known/supported struct */
3423 if (vn_decode_simple_pointer(dec))
3424 assert(false);
3425 }
3426
3427 static inline void
vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceScalarBlockLayoutFeatures * val)3428 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3429 {
3430 /* skip val->{sType,pNext} */
3431 vn_decode_VkBool32(dec, &val->scalarBlockLayout);
3432 }
3433
3434 static inline void
vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceScalarBlockLayoutFeatures * val)3435 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3436 {
3437 VkStructureType stype;
3438 vn_decode_VkStructureType(dec, &stype);
3439 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
3440
3441 assert(val->sType == stype);
3442 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(dec, val->pNext);
3443 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(dec, val);
3444 }
3445
3446 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(const void * val)3447 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(const void *val)
3448 {
3449 /* no known/supported struct */
3450 return vn_sizeof_simple_pointer(NULL);
3451 }
3452
3453 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures * val)3454 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3455 {
3456 size_t size = 0;
3457 /* skip val->{sType,pNext} */
3458 /* skip val->scalarBlockLayout */
3459 return size;
3460 }
3461
3462 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures * val)3463 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3464 {
3465 size_t size = 0;
3466
3467 size += vn_sizeof_VkStructureType(&val->sType);
3468 size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(val->pNext);
3469 size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(val);
3470
3471 return size;
3472 }
3473
3474 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)3475 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3476 {
3477 /* no known/supported struct */
3478 vn_encode_simple_pointer(enc, NULL);
3479 }
3480
3481 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceScalarBlockLayoutFeatures * val)3482 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3483 {
3484 /* skip val->{sType,pNext} */
3485 /* skip val->scalarBlockLayout */
3486 }
3487
3488 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceScalarBlockLayoutFeatures * val)3489 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3490 {
3491 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
3492 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES });
3493 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(enc, val->pNext);
3494 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(enc, val);
3495 }
3496
3497 /* struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures chain */
3498
3499 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(const void * val)3500 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(const void *val)
3501 {
3502 /* no known/supported struct */
3503 return vn_sizeof_simple_pointer(NULL);
3504 }
3505
3506 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3507 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3508 {
3509 size_t size = 0;
3510 /* skip val->{sType,pNext} */
3511 size += vn_sizeof_VkBool32(&val->uniformBufferStandardLayout);
3512 return size;
3513 }
3514
3515 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3516 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3517 {
3518 size_t size = 0;
3519
3520 size += vn_sizeof_VkStructureType(&val->sType);
3521 size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(val->pNext);
3522 size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(val);
3523
3524 return size;
3525 }
3526
3527 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_encoder * enc,const void * val)3528 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
3529 {
3530 /* no known/supported struct */
3531 vn_encode_simple_pointer(enc, NULL);
3532 }
3533
3534 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3535 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3536 {
3537 /* skip val->{sType,pNext} */
3538 vn_encode_VkBool32(enc, &val->uniformBufferStandardLayout);
3539 }
3540
3541 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3542 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3543 {
3544 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
3545 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES });
3546 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(enc, val->pNext);
3547 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, val);
3548 }
3549
3550 static inline void
vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3551 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3552 {
3553 /* no known/supported struct */
3554 if (vn_decode_simple_pointer(dec))
3555 assert(false);
3556 }
3557
3558 static inline void
vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3559 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3560 {
3561 /* skip val->{sType,pNext} */
3562 vn_decode_VkBool32(dec, &val->uniformBufferStandardLayout);
3563 }
3564
3565 static inline void
vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3566 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3567 {
3568 VkStructureType stype;
3569 vn_decode_VkStructureType(dec, &stype);
3570 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
3571
3572 assert(val->sType == stype);
3573 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(dec, val->pNext);
3574 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(dec, val);
3575 }
3576
3577 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(const void * val)3578 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(const void *val)
3579 {
3580 /* no known/supported struct */
3581 return vn_sizeof_simple_pointer(NULL);
3582 }
3583
3584 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3585 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3586 {
3587 size_t size = 0;
3588 /* skip val->{sType,pNext} */
3589 /* skip val->uniformBufferStandardLayout */
3590 return size;
3591 }
3592
3593 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3594 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3595 {
3596 size_t size = 0;
3597
3598 size += vn_sizeof_VkStructureType(&val->sType);
3599 size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(val->pNext);
3600 size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(val);
3601
3602 return size;
3603 }
3604
3605 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)3606 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3607 {
3608 /* no known/supported struct */
3609 vn_encode_simple_pointer(enc, NULL);
3610 }
3611
3612 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3613 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3614 {
3615 /* skip val->{sType,pNext} */
3616 /* skip val->uniformBufferStandardLayout */
3617 }
3618
3619 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3620 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3621 {
3622 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
3623 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES });
3624 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(enc, val->pNext);
3625 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(enc, val);
3626 }
3627
3628 /* struct VkPhysicalDeviceBufferDeviceAddressFeatures chain */
3629
3630 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(const void * val)3631 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(const void *val)
3632 {
3633 /* no known/supported struct */
3634 return vn_sizeof_simple_pointer(NULL);
3635 }
3636
3637 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self(const VkPhysicalDeviceBufferDeviceAddressFeatures * val)3638 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3639 {
3640 size_t size = 0;
3641 /* skip val->{sType,pNext} */
3642 size += vn_sizeof_VkBool32(&val->bufferDeviceAddress);
3643 size += vn_sizeof_VkBool32(&val->bufferDeviceAddressCaptureReplay);
3644 size += vn_sizeof_VkBool32(&val->bufferDeviceAddressMultiDevice);
3645 return size;
3646 }
3647
3648 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures * val)3649 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3650 {
3651 size_t size = 0;
3652
3653 size += vn_sizeof_VkStructureType(&val->sType);
3654 size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(val->pNext);
3655 size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self(val);
3656
3657 return size;
3658 }
3659
3660 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_encoder * enc,const void * val)3661 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
3662 {
3663 /* no known/supported struct */
3664 vn_encode_simple_pointer(enc, NULL);
3665 }
3666
3667 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceBufferDeviceAddressFeatures * val)3668 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3669 {
3670 /* skip val->{sType,pNext} */
3671 vn_encode_VkBool32(enc, &val->bufferDeviceAddress);
3672 vn_encode_VkBool32(enc, &val->bufferDeviceAddressCaptureReplay);
3673 vn_encode_VkBool32(enc, &val->bufferDeviceAddressMultiDevice);
3674 }
3675
3676 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceBufferDeviceAddressFeatures * val)3677 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3678 {
3679 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
3680 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES });
3681 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(enc, val->pNext);
3682 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, val);
3683 }
3684
3685 static inline void
vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3686 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3687 {
3688 /* no known/supported struct */
3689 if (vn_decode_simple_pointer(dec))
3690 assert(false);
3691 }
3692
3693 static inline void
vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceBufferDeviceAddressFeatures * val)3694 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3695 {
3696 /* skip val->{sType,pNext} */
3697 vn_decode_VkBool32(dec, &val->bufferDeviceAddress);
3698 vn_decode_VkBool32(dec, &val->bufferDeviceAddressCaptureReplay);
3699 vn_decode_VkBool32(dec, &val->bufferDeviceAddressMultiDevice);
3700 }
3701
3702 static inline void
vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceBufferDeviceAddressFeatures * val)3703 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3704 {
3705 VkStructureType stype;
3706 vn_decode_VkStructureType(dec, &stype);
3707 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
3708
3709 assert(val->sType == stype);
3710 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(dec, val->pNext);
3711 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(dec, val);
3712 }
3713
3714 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(const void * val)3715 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(const void *val)
3716 {
3717 /* no known/supported struct */
3718 return vn_sizeof_simple_pointer(NULL);
3719 }
3720
3721 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures * val)3722 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3723 {
3724 size_t size = 0;
3725 /* skip val->{sType,pNext} */
3726 /* skip val->bufferDeviceAddress */
3727 /* skip val->bufferDeviceAddressCaptureReplay */
3728 /* skip val->bufferDeviceAddressMultiDevice */
3729 return size;
3730 }
3731
3732 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures * val)3733 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3734 {
3735 size_t size = 0;
3736
3737 size += vn_sizeof_VkStructureType(&val->sType);
3738 size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(val->pNext);
3739 size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(val);
3740
3741 return size;
3742 }
3743
3744 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)3745 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3746 {
3747 /* no known/supported struct */
3748 vn_encode_simple_pointer(enc, NULL);
3749 }
3750
3751 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceBufferDeviceAddressFeatures * val)3752 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3753 {
3754 /* skip val->{sType,pNext} */
3755 /* skip val->bufferDeviceAddress */
3756 /* skip val->bufferDeviceAddressCaptureReplay */
3757 /* skip val->bufferDeviceAddressMultiDevice */
3758 }
3759
3760 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceBufferDeviceAddressFeatures * val)3761 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3762 {
3763 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
3764 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES });
3765 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(enc, val->pNext);
3766 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(enc, val);
3767 }
3768
3769 /* struct VkPhysicalDeviceImagelessFramebufferFeatures chain */
3770
3771 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(const void * val)3772 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(const void *val)
3773 {
3774 /* no known/supported struct */
3775 return vn_sizeof_simple_pointer(NULL);
3776 }
3777
3778 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self(const VkPhysicalDeviceImagelessFramebufferFeatures * val)3779 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
3780 {
3781 size_t size = 0;
3782 /* skip val->{sType,pNext} */
3783 size += vn_sizeof_VkBool32(&val->imagelessFramebuffer);
3784 return size;
3785 }
3786
3787 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures * val)3788 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
3789 {
3790 size_t size = 0;
3791
3792 size += vn_sizeof_VkStructureType(&val->sType);
3793 size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(val->pNext);
3794 size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self(val);
3795
3796 return size;
3797 }
3798
3799 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_encoder * enc,const void * val)3800 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
3801 {
3802 /* no known/supported struct */
3803 vn_encode_simple_pointer(enc, NULL);
3804 }
3805
3806 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceImagelessFramebufferFeatures * val)3807 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
3808 {
3809 /* skip val->{sType,pNext} */
3810 vn_encode_VkBool32(enc, &val->imagelessFramebuffer);
3811 }
3812
3813 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceImagelessFramebufferFeatures * val)3814 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
3815 {
3816 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
3817 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES });
3818 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(enc, val->pNext);
3819 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, val);
3820 }
3821
3822 static inline void
vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3823 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3824 {
3825 /* no known/supported struct */
3826 if (vn_decode_simple_pointer(dec))
3827 assert(false);
3828 }
3829
3830 static inline void
vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceImagelessFramebufferFeatures * val)3831 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceImagelessFramebufferFeatures *val)
3832 {
3833 /* skip val->{sType,pNext} */
3834 vn_decode_VkBool32(dec, &val->imagelessFramebuffer);
3835 }
3836
3837 static inline void
vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceImagelessFramebufferFeatures * val)3838 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceImagelessFramebufferFeatures *val)
3839 {
3840 VkStructureType stype;
3841 vn_decode_VkStructureType(dec, &stype);
3842 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
3843
3844 assert(val->sType == stype);
3845 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(dec, val->pNext);
3846 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(dec, val);
3847 }
3848
3849 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(const void * val)3850 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(const void *val)
3851 {
3852 /* no known/supported struct */
3853 return vn_sizeof_simple_pointer(NULL);
3854 }
3855
3856 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(const VkPhysicalDeviceImagelessFramebufferFeatures * val)3857 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
3858 {
3859 size_t size = 0;
3860 /* skip val->{sType,pNext} */
3861 /* skip val->imagelessFramebuffer */
3862 return size;
3863 }
3864
3865 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_partial(const VkPhysicalDeviceImagelessFramebufferFeatures * val)3866 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_partial(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
3867 {
3868 size_t size = 0;
3869
3870 size += vn_sizeof_VkStructureType(&val->sType);
3871 size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(val->pNext);
3872 size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(val);
3873
3874 return size;
3875 }
3876
3877 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)3878 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3879 {
3880 /* no known/supported struct */
3881 vn_encode_simple_pointer(enc, NULL);
3882 }
3883
3884 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceImagelessFramebufferFeatures * val)3885 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
3886 {
3887 /* skip val->{sType,pNext} */
3888 /* skip val->imagelessFramebuffer */
3889 }
3890
3891 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceImagelessFramebufferFeatures * val)3892 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
3893 {
3894 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
3895 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES });
3896 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(enc, val->pNext);
3897 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(enc, val);
3898 }
3899
3900 /* struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures chain */
3901
3902 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(const void * val)3903 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(const void *val)
3904 {
3905 /* no known/supported struct */
3906 return vn_sizeof_simple_pointer(NULL);
3907 }
3908
3909 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3910 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3911 {
3912 size_t size = 0;
3913 /* skip val->{sType,pNext} */
3914 size += vn_sizeof_VkBool32(&val->separateDepthStencilLayouts);
3915 return size;
3916 }
3917
3918 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3919 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3920 {
3921 size_t size = 0;
3922
3923 size += vn_sizeof_VkStructureType(&val->sType);
3924 size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(val->pNext);
3925 size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(val);
3926
3927 return size;
3928 }
3929
3930 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_encoder * enc,const void * val)3931 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
3932 {
3933 /* no known/supported struct */
3934 vn_encode_simple_pointer(enc, NULL);
3935 }
3936
3937 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3938 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3939 {
3940 /* skip val->{sType,pNext} */
3941 vn_encode_VkBool32(enc, &val->separateDepthStencilLayouts);
3942 }
3943
3944 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3945 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3946 {
3947 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
3948 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES });
3949 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(enc, val->pNext);
3950 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, val);
3951 }
3952
3953 static inline void
vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3954 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3955 {
3956 /* no known/supported struct */
3957 if (vn_decode_simple_pointer(dec))
3958 assert(false);
3959 }
3960
3961 static inline void
vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3962 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3963 {
3964 /* skip val->{sType,pNext} */
3965 vn_decode_VkBool32(dec, &val->separateDepthStencilLayouts);
3966 }
3967
3968 static inline void
vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3969 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3970 {
3971 VkStructureType stype;
3972 vn_decode_VkStructureType(dec, &stype);
3973 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
3974
3975 assert(val->sType == stype);
3976 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(dec, val->pNext);
3977 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(dec, val);
3978 }
3979
3980 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(const void * val)3981 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(const void *val)
3982 {
3983 /* no known/supported struct */
3984 return vn_sizeof_simple_pointer(NULL);
3985 }
3986
3987 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3988 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3989 {
3990 size_t size = 0;
3991 /* skip val->{sType,pNext} */
3992 /* skip val->separateDepthStencilLayouts */
3993 return size;
3994 }
3995
3996 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3997 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3998 {
3999 size_t size = 0;
4000
4001 size += vn_sizeof_VkStructureType(&val->sType);
4002 size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(val->pNext);
4003 size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(val);
4004
4005 return size;
4006 }
4007
4008 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)4009 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4010 {
4011 /* no known/supported struct */
4012 vn_encode_simple_pointer(enc, NULL);
4013 }
4014
4015 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)4016 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
4017 {
4018 /* skip val->{sType,pNext} */
4019 /* skip val->separateDepthStencilLayouts */
4020 }
4021
4022 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)4023 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
4024 {
4025 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
4026 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES });
4027 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(enc, val->pNext);
4028 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(enc, val);
4029 }
4030
4031 /* struct VkPhysicalDeviceVulkan11Features chain */
4032
4033 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext(const void * val)4034 vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext(const void *val)
4035 {
4036 /* no known/supported struct */
4037 return vn_sizeof_simple_pointer(NULL);
4038 }
4039
4040 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_self(const VkPhysicalDeviceVulkan11Features * val)4041 vn_sizeof_VkPhysicalDeviceVulkan11Features_self(const VkPhysicalDeviceVulkan11Features *val)
4042 {
4043 size_t size = 0;
4044 /* skip val->{sType,pNext} */
4045 size += vn_sizeof_VkBool32(&val->storageBuffer16BitAccess);
4046 size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer16BitAccess);
4047 size += vn_sizeof_VkBool32(&val->storagePushConstant16);
4048 size += vn_sizeof_VkBool32(&val->storageInputOutput16);
4049 size += vn_sizeof_VkBool32(&val->multiview);
4050 size += vn_sizeof_VkBool32(&val->multiviewGeometryShader);
4051 size += vn_sizeof_VkBool32(&val->multiviewTessellationShader);
4052 size += vn_sizeof_VkBool32(&val->variablePointersStorageBuffer);
4053 size += vn_sizeof_VkBool32(&val->variablePointers);
4054 size += vn_sizeof_VkBool32(&val->protectedMemory);
4055 size += vn_sizeof_VkBool32(&val->samplerYcbcrConversion);
4056 size += vn_sizeof_VkBool32(&val->shaderDrawParameters);
4057 return size;
4058 }
4059
4060 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features * val)4061 vn_sizeof_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features *val)
4062 {
4063 size_t size = 0;
4064
4065 size += vn_sizeof_VkStructureType(&val->sType);
4066 size += vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext(val->pNext);
4067 size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self(val);
4068
4069 return size;
4070 }
4071
4072 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_encoder * enc,const void * val)4073 vn_encode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_encoder *enc, const void *val)
4074 {
4075 /* no known/supported struct */
4076 vn_encode_simple_pointer(enc, NULL);
4077 }
4078
4079 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Features * val)4080 vn_encode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
4081 {
4082 /* skip val->{sType,pNext} */
4083 vn_encode_VkBool32(enc, &val->storageBuffer16BitAccess);
4084 vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer16BitAccess);
4085 vn_encode_VkBool32(enc, &val->storagePushConstant16);
4086 vn_encode_VkBool32(enc, &val->storageInputOutput16);
4087 vn_encode_VkBool32(enc, &val->multiview);
4088 vn_encode_VkBool32(enc, &val->multiviewGeometryShader);
4089 vn_encode_VkBool32(enc, &val->multiviewTessellationShader);
4090 vn_encode_VkBool32(enc, &val->variablePointersStorageBuffer);
4091 vn_encode_VkBool32(enc, &val->variablePointers);
4092 vn_encode_VkBool32(enc, &val->protectedMemory);
4093 vn_encode_VkBool32(enc, &val->samplerYcbcrConversion);
4094 vn_encode_VkBool32(enc, &val->shaderDrawParameters);
4095 }
4096
4097 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Features * val)4098 vn_encode_VkPhysicalDeviceVulkan11Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
4099 {
4100 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
4101 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES });
4102 vn_encode_VkPhysicalDeviceVulkan11Features_pnext(enc, val->pNext);
4103 vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, val);
4104 }
4105
4106 static inline void
vn_decode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_decoder * dec,const void * val)4107 vn_decode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_decoder *dec, const void *val)
4108 {
4109 /* no known/supported struct */
4110 if (vn_decode_simple_pointer(dec))
4111 assert(false);
4112 }
4113
4114 static inline void
vn_decode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Features * val)4115 vn_decode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Features *val)
4116 {
4117 /* skip val->{sType,pNext} */
4118 vn_decode_VkBool32(dec, &val->storageBuffer16BitAccess);
4119 vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer16BitAccess);
4120 vn_decode_VkBool32(dec, &val->storagePushConstant16);
4121 vn_decode_VkBool32(dec, &val->storageInputOutput16);
4122 vn_decode_VkBool32(dec, &val->multiview);
4123 vn_decode_VkBool32(dec, &val->multiviewGeometryShader);
4124 vn_decode_VkBool32(dec, &val->multiviewTessellationShader);
4125 vn_decode_VkBool32(dec, &val->variablePointersStorageBuffer);
4126 vn_decode_VkBool32(dec, &val->variablePointers);
4127 vn_decode_VkBool32(dec, &val->protectedMemory);
4128 vn_decode_VkBool32(dec, &val->samplerYcbcrConversion);
4129 vn_decode_VkBool32(dec, &val->shaderDrawParameters);
4130 }
4131
4132 static inline void
vn_decode_VkPhysicalDeviceVulkan11Features(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Features * val)4133 vn_decode_VkPhysicalDeviceVulkan11Features(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Features *val)
4134 {
4135 VkStructureType stype;
4136 vn_decode_VkStructureType(dec, &stype);
4137 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
4138
4139 assert(val->sType == stype);
4140 vn_decode_VkPhysicalDeviceVulkan11Features_pnext(dec, val->pNext);
4141 vn_decode_VkPhysicalDeviceVulkan11Features_self(dec, val);
4142 }
4143
4144 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext_partial(const void * val)4145 vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext_partial(const void *val)
4146 {
4147 /* no known/supported struct */
4148 return vn_sizeof_simple_pointer(NULL);
4149 }
4150
4151 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial(const VkPhysicalDeviceVulkan11Features * val)4152 vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial(const VkPhysicalDeviceVulkan11Features *val)
4153 {
4154 size_t size = 0;
4155 /* skip val->{sType,pNext} */
4156 /* skip val->storageBuffer16BitAccess */
4157 /* skip val->uniformAndStorageBuffer16BitAccess */
4158 /* skip val->storagePushConstant16 */
4159 /* skip val->storageInputOutput16 */
4160 /* skip val->multiview */
4161 /* skip val->multiviewGeometryShader */
4162 /* skip val->multiviewTessellationShader */
4163 /* skip val->variablePointersStorageBuffer */
4164 /* skip val->variablePointers */
4165 /* skip val->protectedMemory */
4166 /* skip val->samplerYcbcrConversion */
4167 /* skip val->shaderDrawParameters */
4168 return size;
4169 }
4170
4171 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_partial(const VkPhysicalDeviceVulkan11Features * val)4172 vn_sizeof_VkPhysicalDeviceVulkan11Features_partial(const VkPhysicalDeviceVulkan11Features *val)
4173 {
4174 size_t size = 0;
4175
4176 size += vn_sizeof_VkStructureType(&val->sType);
4177 size += vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext_partial(val->pNext);
4178 size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial(val);
4179
4180 return size;
4181 }
4182
4183 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)4184 vn_encode_VkPhysicalDeviceVulkan11Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4185 {
4186 /* no known/supported struct */
4187 vn_encode_simple_pointer(enc, NULL);
4188 }
4189
4190 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Features * val)4191 vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
4192 {
4193 /* skip val->{sType,pNext} */
4194 /* skip val->storageBuffer16BitAccess */
4195 /* skip val->uniformAndStorageBuffer16BitAccess */
4196 /* skip val->storagePushConstant16 */
4197 /* skip val->storageInputOutput16 */
4198 /* skip val->multiview */
4199 /* skip val->multiviewGeometryShader */
4200 /* skip val->multiviewTessellationShader */
4201 /* skip val->variablePointersStorageBuffer */
4202 /* skip val->variablePointers */
4203 /* skip val->protectedMemory */
4204 /* skip val->samplerYcbcrConversion */
4205 /* skip val->shaderDrawParameters */
4206 }
4207
4208 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Features * val)4209 vn_encode_VkPhysicalDeviceVulkan11Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
4210 {
4211 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
4212 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES });
4213 vn_encode_VkPhysicalDeviceVulkan11Features_pnext_partial(enc, val->pNext);
4214 vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(enc, val);
4215 }
4216
4217 /* struct VkPhysicalDeviceVulkan12Features chain */
4218
4219 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext(const void * val)4220 vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext(const void *val)
4221 {
4222 /* no known/supported struct */
4223 return vn_sizeof_simple_pointer(NULL);
4224 }
4225
4226 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_self(const VkPhysicalDeviceVulkan12Features * val)4227 vn_sizeof_VkPhysicalDeviceVulkan12Features_self(const VkPhysicalDeviceVulkan12Features *val)
4228 {
4229 size_t size = 0;
4230 /* skip val->{sType,pNext} */
4231 size += vn_sizeof_VkBool32(&val->samplerMirrorClampToEdge);
4232 size += vn_sizeof_VkBool32(&val->drawIndirectCount);
4233 size += vn_sizeof_VkBool32(&val->storageBuffer8BitAccess);
4234 size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer8BitAccess);
4235 size += vn_sizeof_VkBool32(&val->storagePushConstant8);
4236 size += vn_sizeof_VkBool32(&val->shaderBufferInt64Atomics);
4237 size += vn_sizeof_VkBool32(&val->shaderSharedInt64Atomics);
4238 size += vn_sizeof_VkBool32(&val->shaderFloat16);
4239 size += vn_sizeof_VkBool32(&val->shaderInt8);
4240 size += vn_sizeof_VkBool32(&val->descriptorIndexing);
4241 size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayDynamicIndexing);
4242 size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayDynamicIndexing);
4243 size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayDynamicIndexing);
4244 size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexing);
4245 size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexing);
4246 size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexing);
4247 size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexing);
4248 size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexing);
4249 size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayNonUniformIndexing);
4250 size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayNonUniformIndexing);
4251 size += vn_sizeof_VkBool32(&val->descriptorBindingUniformBufferUpdateAfterBind);
4252 size += vn_sizeof_VkBool32(&val->descriptorBindingSampledImageUpdateAfterBind);
4253 size += vn_sizeof_VkBool32(&val->descriptorBindingStorageImageUpdateAfterBind);
4254 size += vn_sizeof_VkBool32(&val->descriptorBindingStorageBufferUpdateAfterBind);
4255 size += vn_sizeof_VkBool32(&val->descriptorBindingUniformTexelBufferUpdateAfterBind);
4256 size += vn_sizeof_VkBool32(&val->descriptorBindingStorageTexelBufferUpdateAfterBind);
4257 size += vn_sizeof_VkBool32(&val->descriptorBindingUpdateUnusedWhilePending);
4258 size += vn_sizeof_VkBool32(&val->descriptorBindingPartiallyBound);
4259 size += vn_sizeof_VkBool32(&val->descriptorBindingVariableDescriptorCount);
4260 size += vn_sizeof_VkBool32(&val->runtimeDescriptorArray);
4261 size += vn_sizeof_VkBool32(&val->samplerFilterMinmax);
4262 size += vn_sizeof_VkBool32(&val->scalarBlockLayout);
4263 size += vn_sizeof_VkBool32(&val->imagelessFramebuffer);
4264 size += vn_sizeof_VkBool32(&val->uniformBufferStandardLayout);
4265 size += vn_sizeof_VkBool32(&val->shaderSubgroupExtendedTypes);
4266 size += vn_sizeof_VkBool32(&val->separateDepthStencilLayouts);
4267 size += vn_sizeof_VkBool32(&val->hostQueryReset);
4268 size += vn_sizeof_VkBool32(&val->timelineSemaphore);
4269 size += vn_sizeof_VkBool32(&val->bufferDeviceAddress);
4270 size += vn_sizeof_VkBool32(&val->bufferDeviceAddressCaptureReplay);
4271 size += vn_sizeof_VkBool32(&val->bufferDeviceAddressMultiDevice);
4272 size += vn_sizeof_VkBool32(&val->vulkanMemoryModel);
4273 size += vn_sizeof_VkBool32(&val->vulkanMemoryModelDeviceScope);
4274 size += vn_sizeof_VkBool32(&val->vulkanMemoryModelAvailabilityVisibilityChains);
4275 size += vn_sizeof_VkBool32(&val->shaderOutputViewportIndex);
4276 size += vn_sizeof_VkBool32(&val->shaderOutputLayer);
4277 size += vn_sizeof_VkBool32(&val->subgroupBroadcastDynamicId);
4278 return size;
4279 }
4280
4281 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features * val)4282 vn_sizeof_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features *val)
4283 {
4284 size_t size = 0;
4285
4286 size += vn_sizeof_VkStructureType(&val->sType);
4287 size += vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext(val->pNext);
4288 size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self(val);
4289
4290 return size;
4291 }
4292
4293 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_encoder * enc,const void * val)4294 vn_encode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_encoder *enc, const void *val)
4295 {
4296 /* no known/supported struct */
4297 vn_encode_simple_pointer(enc, NULL);
4298 }
4299
4300 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Features * val)4301 vn_encode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
4302 {
4303 /* skip val->{sType,pNext} */
4304 vn_encode_VkBool32(enc, &val->samplerMirrorClampToEdge);
4305 vn_encode_VkBool32(enc, &val->drawIndirectCount);
4306 vn_encode_VkBool32(enc, &val->storageBuffer8BitAccess);
4307 vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer8BitAccess);
4308 vn_encode_VkBool32(enc, &val->storagePushConstant8);
4309 vn_encode_VkBool32(enc, &val->shaderBufferInt64Atomics);
4310 vn_encode_VkBool32(enc, &val->shaderSharedInt64Atomics);
4311 vn_encode_VkBool32(enc, &val->shaderFloat16);
4312 vn_encode_VkBool32(enc, &val->shaderInt8);
4313 vn_encode_VkBool32(enc, &val->descriptorIndexing);
4314 vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayDynamicIndexing);
4315 vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayDynamicIndexing);
4316 vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayDynamicIndexing);
4317 vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayNonUniformIndexing);
4318 vn_encode_VkBool32(enc, &val->shaderSampledImageArrayNonUniformIndexing);
4319 vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayNonUniformIndexing);
4320 vn_encode_VkBool32(enc, &val->shaderStorageImageArrayNonUniformIndexing);
4321 vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayNonUniformIndexing);
4322 vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
4323 vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
4324 vn_encode_VkBool32(enc, &val->descriptorBindingUniformBufferUpdateAfterBind);
4325 vn_encode_VkBool32(enc, &val->descriptorBindingSampledImageUpdateAfterBind);
4326 vn_encode_VkBool32(enc, &val->descriptorBindingStorageImageUpdateAfterBind);
4327 vn_encode_VkBool32(enc, &val->descriptorBindingStorageBufferUpdateAfterBind);
4328 vn_encode_VkBool32(enc, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
4329 vn_encode_VkBool32(enc, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
4330 vn_encode_VkBool32(enc, &val->descriptorBindingUpdateUnusedWhilePending);
4331 vn_encode_VkBool32(enc, &val->descriptorBindingPartiallyBound);
4332 vn_encode_VkBool32(enc, &val->descriptorBindingVariableDescriptorCount);
4333 vn_encode_VkBool32(enc, &val->runtimeDescriptorArray);
4334 vn_encode_VkBool32(enc, &val->samplerFilterMinmax);
4335 vn_encode_VkBool32(enc, &val->scalarBlockLayout);
4336 vn_encode_VkBool32(enc, &val->imagelessFramebuffer);
4337 vn_encode_VkBool32(enc, &val->uniformBufferStandardLayout);
4338 vn_encode_VkBool32(enc, &val->shaderSubgroupExtendedTypes);
4339 vn_encode_VkBool32(enc, &val->separateDepthStencilLayouts);
4340 vn_encode_VkBool32(enc, &val->hostQueryReset);
4341 vn_encode_VkBool32(enc, &val->timelineSemaphore);
4342 vn_encode_VkBool32(enc, &val->bufferDeviceAddress);
4343 vn_encode_VkBool32(enc, &val->bufferDeviceAddressCaptureReplay);
4344 vn_encode_VkBool32(enc, &val->bufferDeviceAddressMultiDevice);
4345 vn_encode_VkBool32(enc, &val->vulkanMemoryModel);
4346 vn_encode_VkBool32(enc, &val->vulkanMemoryModelDeviceScope);
4347 vn_encode_VkBool32(enc, &val->vulkanMemoryModelAvailabilityVisibilityChains);
4348 vn_encode_VkBool32(enc, &val->shaderOutputViewportIndex);
4349 vn_encode_VkBool32(enc, &val->shaderOutputLayer);
4350 vn_encode_VkBool32(enc, &val->subgroupBroadcastDynamicId);
4351 }
4352
4353 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Features * val)4354 vn_encode_VkPhysicalDeviceVulkan12Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
4355 {
4356 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
4357 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES });
4358 vn_encode_VkPhysicalDeviceVulkan12Features_pnext(enc, val->pNext);
4359 vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, val);
4360 }
4361
4362 static inline void
vn_decode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_decoder * dec,const void * val)4363 vn_decode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_decoder *dec, const void *val)
4364 {
4365 /* no known/supported struct */
4366 if (vn_decode_simple_pointer(dec))
4367 assert(false);
4368 }
4369
4370 static inline void
vn_decode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Features * val)4371 vn_decode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Features *val)
4372 {
4373 /* skip val->{sType,pNext} */
4374 vn_decode_VkBool32(dec, &val->samplerMirrorClampToEdge);
4375 vn_decode_VkBool32(dec, &val->drawIndirectCount);
4376 vn_decode_VkBool32(dec, &val->storageBuffer8BitAccess);
4377 vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer8BitAccess);
4378 vn_decode_VkBool32(dec, &val->storagePushConstant8);
4379 vn_decode_VkBool32(dec, &val->shaderBufferInt64Atomics);
4380 vn_decode_VkBool32(dec, &val->shaderSharedInt64Atomics);
4381 vn_decode_VkBool32(dec, &val->shaderFloat16);
4382 vn_decode_VkBool32(dec, &val->shaderInt8);
4383 vn_decode_VkBool32(dec, &val->descriptorIndexing);
4384 vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayDynamicIndexing);
4385 vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayDynamicIndexing);
4386 vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayDynamicIndexing);
4387 vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexing);
4388 vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexing);
4389 vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexing);
4390 vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexing);
4391 vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexing);
4392 vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
4393 vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
4394 vn_decode_VkBool32(dec, &val->descriptorBindingUniformBufferUpdateAfterBind);
4395 vn_decode_VkBool32(dec, &val->descriptorBindingSampledImageUpdateAfterBind);
4396 vn_decode_VkBool32(dec, &val->descriptorBindingStorageImageUpdateAfterBind);
4397 vn_decode_VkBool32(dec, &val->descriptorBindingStorageBufferUpdateAfterBind);
4398 vn_decode_VkBool32(dec, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
4399 vn_decode_VkBool32(dec, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
4400 vn_decode_VkBool32(dec, &val->descriptorBindingUpdateUnusedWhilePending);
4401 vn_decode_VkBool32(dec, &val->descriptorBindingPartiallyBound);
4402 vn_decode_VkBool32(dec, &val->descriptorBindingVariableDescriptorCount);
4403 vn_decode_VkBool32(dec, &val->runtimeDescriptorArray);
4404 vn_decode_VkBool32(dec, &val->samplerFilterMinmax);
4405 vn_decode_VkBool32(dec, &val->scalarBlockLayout);
4406 vn_decode_VkBool32(dec, &val->imagelessFramebuffer);
4407 vn_decode_VkBool32(dec, &val->uniformBufferStandardLayout);
4408 vn_decode_VkBool32(dec, &val->shaderSubgroupExtendedTypes);
4409 vn_decode_VkBool32(dec, &val->separateDepthStencilLayouts);
4410 vn_decode_VkBool32(dec, &val->hostQueryReset);
4411 vn_decode_VkBool32(dec, &val->timelineSemaphore);
4412 vn_decode_VkBool32(dec, &val->bufferDeviceAddress);
4413 vn_decode_VkBool32(dec, &val->bufferDeviceAddressCaptureReplay);
4414 vn_decode_VkBool32(dec, &val->bufferDeviceAddressMultiDevice);
4415 vn_decode_VkBool32(dec, &val->vulkanMemoryModel);
4416 vn_decode_VkBool32(dec, &val->vulkanMemoryModelDeviceScope);
4417 vn_decode_VkBool32(dec, &val->vulkanMemoryModelAvailabilityVisibilityChains);
4418 vn_decode_VkBool32(dec, &val->shaderOutputViewportIndex);
4419 vn_decode_VkBool32(dec, &val->shaderOutputLayer);
4420 vn_decode_VkBool32(dec, &val->subgroupBroadcastDynamicId);
4421 }
4422
4423 static inline void
vn_decode_VkPhysicalDeviceVulkan12Features(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Features * val)4424 vn_decode_VkPhysicalDeviceVulkan12Features(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Features *val)
4425 {
4426 VkStructureType stype;
4427 vn_decode_VkStructureType(dec, &stype);
4428 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
4429
4430 assert(val->sType == stype);
4431 vn_decode_VkPhysicalDeviceVulkan12Features_pnext(dec, val->pNext);
4432 vn_decode_VkPhysicalDeviceVulkan12Features_self(dec, val);
4433 }
4434
4435 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext_partial(const void * val)4436 vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext_partial(const void *val)
4437 {
4438 /* no known/supported struct */
4439 return vn_sizeof_simple_pointer(NULL);
4440 }
4441
4442 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial(const VkPhysicalDeviceVulkan12Features * val)4443 vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial(const VkPhysicalDeviceVulkan12Features *val)
4444 {
4445 size_t size = 0;
4446 /* skip val->{sType,pNext} */
4447 /* skip val->samplerMirrorClampToEdge */
4448 /* skip val->drawIndirectCount */
4449 /* skip val->storageBuffer8BitAccess */
4450 /* skip val->uniformAndStorageBuffer8BitAccess */
4451 /* skip val->storagePushConstant8 */
4452 /* skip val->shaderBufferInt64Atomics */
4453 /* skip val->shaderSharedInt64Atomics */
4454 /* skip val->shaderFloat16 */
4455 /* skip val->shaderInt8 */
4456 /* skip val->descriptorIndexing */
4457 /* skip val->shaderInputAttachmentArrayDynamicIndexing */
4458 /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
4459 /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
4460 /* skip val->shaderUniformBufferArrayNonUniformIndexing */
4461 /* skip val->shaderSampledImageArrayNonUniformIndexing */
4462 /* skip val->shaderStorageBufferArrayNonUniformIndexing */
4463 /* skip val->shaderStorageImageArrayNonUniformIndexing */
4464 /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
4465 /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
4466 /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
4467 /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
4468 /* skip val->descriptorBindingSampledImageUpdateAfterBind */
4469 /* skip val->descriptorBindingStorageImageUpdateAfterBind */
4470 /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
4471 /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
4472 /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
4473 /* skip val->descriptorBindingUpdateUnusedWhilePending */
4474 /* skip val->descriptorBindingPartiallyBound */
4475 /* skip val->descriptorBindingVariableDescriptorCount */
4476 /* skip val->runtimeDescriptorArray */
4477 /* skip val->samplerFilterMinmax */
4478 /* skip val->scalarBlockLayout */
4479 /* skip val->imagelessFramebuffer */
4480 /* skip val->uniformBufferStandardLayout */
4481 /* skip val->shaderSubgroupExtendedTypes */
4482 /* skip val->separateDepthStencilLayouts */
4483 /* skip val->hostQueryReset */
4484 /* skip val->timelineSemaphore */
4485 /* skip val->bufferDeviceAddress */
4486 /* skip val->bufferDeviceAddressCaptureReplay */
4487 /* skip val->bufferDeviceAddressMultiDevice */
4488 /* skip val->vulkanMemoryModel */
4489 /* skip val->vulkanMemoryModelDeviceScope */
4490 /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
4491 /* skip val->shaderOutputViewportIndex */
4492 /* skip val->shaderOutputLayer */
4493 /* skip val->subgroupBroadcastDynamicId */
4494 return size;
4495 }
4496
4497 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_partial(const VkPhysicalDeviceVulkan12Features * val)4498 vn_sizeof_VkPhysicalDeviceVulkan12Features_partial(const VkPhysicalDeviceVulkan12Features *val)
4499 {
4500 size_t size = 0;
4501
4502 size += vn_sizeof_VkStructureType(&val->sType);
4503 size += vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext_partial(val->pNext);
4504 size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial(val);
4505
4506 return size;
4507 }
4508
4509 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)4510 vn_encode_VkPhysicalDeviceVulkan12Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4511 {
4512 /* no known/supported struct */
4513 vn_encode_simple_pointer(enc, NULL);
4514 }
4515
4516 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Features * val)4517 vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
4518 {
4519 /* skip val->{sType,pNext} */
4520 /* skip val->samplerMirrorClampToEdge */
4521 /* skip val->drawIndirectCount */
4522 /* skip val->storageBuffer8BitAccess */
4523 /* skip val->uniformAndStorageBuffer8BitAccess */
4524 /* skip val->storagePushConstant8 */
4525 /* skip val->shaderBufferInt64Atomics */
4526 /* skip val->shaderSharedInt64Atomics */
4527 /* skip val->shaderFloat16 */
4528 /* skip val->shaderInt8 */
4529 /* skip val->descriptorIndexing */
4530 /* skip val->shaderInputAttachmentArrayDynamicIndexing */
4531 /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
4532 /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
4533 /* skip val->shaderUniformBufferArrayNonUniformIndexing */
4534 /* skip val->shaderSampledImageArrayNonUniformIndexing */
4535 /* skip val->shaderStorageBufferArrayNonUniformIndexing */
4536 /* skip val->shaderStorageImageArrayNonUniformIndexing */
4537 /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
4538 /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
4539 /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
4540 /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
4541 /* skip val->descriptorBindingSampledImageUpdateAfterBind */
4542 /* skip val->descriptorBindingStorageImageUpdateAfterBind */
4543 /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
4544 /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
4545 /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
4546 /* skip val->descriptorBindingUpdateUnusedWhilePending */
4547 /* skip val->descriptorBindingPartiallyBound */
4548 /* skip val->descriptorBindingVariableDescriptorCount */
4549 /* skip val->runtimeDescriptorArray */
4550 /* skip val->samplerFilterMinmax */
4551 /* skip val->scalarBlockLayout */
4552 /* skip val->imagelessFramebuffer */
4553 /* skip val->uniformBufferStandardLayout */
4554 /* skip val->shaderSubgroupExtendedTypes */
4555 /* skip val->separateDepthStencilLayouts */
4556 /* skip val->hostQueryReset */
4557 /* skip val->timelineSemaphore */
4558 /* skip val->bufferDeviceAddress */
4559 /* skip val->bufferDeviceAddressCaptureReplay */
4560 /* skip val->bufferDeviceAddressMultiDevice */
4561 /* skip val->vulkanMemoryModel */
4562 /* skip val->vulkanMemoryModelDeviceScope */
4563 /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
4564 /* skip val->shaderOutputViewportIndex */
4565 /* skip val->shaderOutputLayer */
4566 /* skip val->subgroupBroadcastDynamicId */
4567 }
4568
4569 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Features * val)4570 vn_encode_VkPhysicalDeviceVulkan12Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
4571 {
4572 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
4573 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES });
4574 vn_encode_VkPhysicalDeviceVulkan12Features_pnext_partial(enc, val->pNext);
4575 vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(enc, val);
4576 }
4577
4578 /* struct VkPhysicalDeviceFeatures2 chain */
4579
4580 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_pnext(const void * val)4581 vn_sizeof_VkPhysicalDeviceFeatures2_pnext(const void *val)
4582 {
4583 const VkBaseInStructure *pnext = val;
4584 size_t size = 0;
4585
4586 while (pnext) {
4587 switch ((int32_t)pnext->sType) {
4588 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
4589 size += vn_sizeof_simple_pointer(pnext);
4590 size += vn_sizeof_VkStructureType(&pnext->sType);
4591 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4592 size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self((const VkPhysicalDeviceVariablePointersFeatures *)pnext);
4593 return size;
4594 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
4595 size += vn_sizeof_simple_pointer(pnext);
4596 size += vn_sizeof_VkStructureType(&pnext->sType);
4597 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4598 size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self((const VkPhysicalDeviceMultiviewFeatures *)pnext);
4599 return size;
4600 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
4601 size += vn_sizeof_simple_pointer(pnext);
4602 size += vn_sizeof_VkStructureType(&pnext->sType);
4603 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4604 size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self((const VkPhysicalDevice16BitStorageFeatures *)pnext);
4605 return size;
4606 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
4607 size += vn_sizeof_simple_pointer(pnext);
4608 size += vn_sizeof_VkStructureType(&pnext->sType);
4609 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4610 size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
4611 return size;
4612 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
4613 size += vn_sizeof_simple_pointer(pnext);
4614 size += vn_sizeof_VkStructureType(&pnext->sType);
4615 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4616 size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
4617 return size;
4618 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
4619 size += vn_sizeof_simple_pointer(pnext);
4620 size += vn_sizeof_VkStructureType(&pnext->sType);
4621 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4622 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
4623 return size;
4624 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
4625 size += vn_sizeof_simple_pointer(pnext);
4626 size += vn_sizeof_VkStructureType(&pnext->sType);
4627 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4628 size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
4629 return size;
4630 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
4631 size += vn_sizeof_simple_pointer(pnext);
4632 size += vn_sizeof_VkStructureType(&pnext->sType);
4633 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4634 size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
4635 return size;
4636 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
4637 size += vn_sizeof_simple_pointer(pnext);
4638 size += vn_sizeof_VkStructureType(&pnext->sType);
4639 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4640 size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self((const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
4641 return size;
4642 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
4643 size += vn_sizeof_simple_pointer(pnext);
4644 size += vn_sizeof_VkStructureType(&pnext->sType);
4645 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4646 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
4647 return size;
4648 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
4649 size += vn_sizeof_simple_pointer(pnext);
4650 size += vn_sizeof_VkStructureType(&pnext->sType);
4651 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4652 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
4653 return size;
4654 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
4655 size += vn_sizeof_simple_pointer(pnext);
4656 size += vn_sizeof_VkStructureType(&pnext->sType);
4657 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4658 size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self((const VkPhysicalDevice8BitStorageFeatures *)pnext);
4659 return size;
4660 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
4661 size += vn_sizeof_simple_pointer(pnext);
4662 size += vn_sizeof_VkStructureType(&pnext->sType);
4663 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4664 size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
4665 return size;
4666 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
4667 size += vn_sizeof_simple_pointer(pnext);
4668 size += vn_sizeof_VkStructureType(&pnext->sType);
4669 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4670 size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
4671 return size;
4672 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
4673 size += vn_sizeof_simple_pointer(pnext);
4674 size += vn_sizeof_VkStructureType(&pnext->sType);
4675 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4676 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
4677 return size;
4678 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
4679 size += vn_sizeof_simple_pointer(pnext);
4680 size += vn_sizeof_VkStructureType(&pnext->sType);
4681 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4682 size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
4683 return size;
4684 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
4685 size += vn_sizeof_simple_pointer(pnext);
4686 size += vn_sizeof_VkStructureType(&pnext->sType);
4687 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4688 size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
4689 return size;
4690 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
4691 size += vn_sizeof_simple_pointer(pnext);
4692 size += vn_sizeof_VkStructureType(&pnext->sType);
4693 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4694 size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
4695 return size;
4696 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
4697 size += vn_sizeof_simple_pointer(pnext);
4698 size += vn_sizeof_VkStructureType(&pnext->sType);
4699 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4700 size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
4701 return size;
4702 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
4703 size += vn_sizeof_simple_pointer(pnext);
4704 size += vn_sizeof_VkStructureType(&pnext->sType);
4705 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4706 size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
4707 return size;
4708 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
4709 size += vn_sizeof_simple_pointer(pnext);
4710 size += vn_sizeof_VkStructureType(&pnext->sType);
4711 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4712 size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self((const VkPhysicalDeviceVulkan11Features *)pnext);
4713 return size;
4714 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
4715 size += vn_sizeof_simple_pointer(pnext);
4716 size += vn_sizeof_VkStructureType(&pnext->sType);
4717 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4718 size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self((const VkPhysicalDeviceVulkan12Features *)pnext);
4719 return size;
4720 default:
4721 /* ignore unknown/unsupported struct */
4722 break;
4723 }
4724 pnext = pnext->pNext;
4725 }
4726
4727 return vn_sizeof_simple_pointer(NULL);
4728 }
4729
4730 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_self(const VkPhysicalDeviceFeatures2 * val)4731 vn_sizeof_VkPhysicalDeviceFeatures2_self(const VkPhysicalDeviceFeatures2 *val)
4732 {
4733 size_t size = 0;
4734 /* skip val->{sType,pNext} */
4735 size += vn_sizeof_VkPhysicalDeviceFeatures(&val->features);
4736 return size;
4737 }
4738
4739 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2 * val)4740 vn_sizeof_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2 *val)
4741 {
4742 size_t size = 0;
4743
4744 size += vn_sizeof_VkStructureType(&val->sType);
4745 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(val->pNext);
4746 size += vn_sizeof_VkPhysicalDeviceFeatures2_self(val);
4747
4748 return size;
4749 }
4750
4751 static inline void
vn_encode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_encoder * enc,const void * val)4752 vn_encode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_encoder *enc, const void *val)
4753 {
4754 const VkBaseInStructure *pnext = val;
4755
4756 while (pnext) {
4757 switch ((int32_t)pnext->sType) {
4758 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
4759 vn_encode_simple_pointer(enc, pnext);
4760 vn_encode_VkStructureType(enc, &pnext->sType);
4761 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4762 vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext);
4763 return;
4764 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
4765 vn_encode_simple_pointer(enc, pnext);
4766 vn_encode_VkStructureType(enc, &pnext->sType);
4767 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4768 vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext);
4769 return;
4770 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
4771 vn_encode_simple_pointer(enc, pnext);
4772 vn_encode_VkStructureType(enc, &pnext->sType);
4773 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4774 vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext);
4775 return;
4776 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
4777 vn_encode_simple_pointer(enc, pnext);
4778 vn_encode_VkStructureType(enc, &pnext->sType);
4779 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4780 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
4781 return;
4782 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
4783 vn_encode_simple_pointer(enc, pnext);
4784 vn_encode_VkStructureType(enc, &pnext->sType);
4785 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4786 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
4787 return;
4788 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
4789 vn_encode_simple_pointer(enc, pnext);
4790 vn_encode_VkStructureType(enc, &pnext->sType);
4791 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4792 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
4793 return;
4794 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
4795 vn_encode_simple_pointer(enc, pnext);
4796 vn_encode_VkStructureType(enc, &pnext->sType);
4797 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4798 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
4799 return;
4800 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
4801 vn_encode_simple_pointer(enc, pnext);
4802 vn_encode_VkStructureType(enc, &pnext->sType);
4803 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4804 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
4805 return;
4806 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
4807 vn_encode_simple_pointer(enc, pnext);
4808 vn_encode_VkStructureType(enc, &pnext->sType);
4809 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4810 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
4811 return;
4812 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
4813 vn_encode_simple_pointer(enc, pnext);
4814 vn_encode_VkStructureType(enc, &pnext->sType);
4815 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4816 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
4817 return;
4818 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
4819 vn_encode_simple_pointer(enc, pnext);
4820 vn_encode_VkStructureType(enc, &pnext->sType);
4821 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4822 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
4823 return;
4824 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
4825 vn_encode_simple_pointer(enc, pnext);
4826 vn_encode_VkStructureType(enc, &pnext->sType);
4827 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4828 vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext);
4829 return;
4830 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
4831 vn_encode_simple_pointer(enc, pnext);
4832 vn_encode_VkStructureType(enc, &pnext->sType);
4833 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4834 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
4835 return;
4836 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
4837 vn_encode_simple_pointer(enc, pnext);
4838 vn_encode_VkStructureType(enc, &pnext->sType);
4839 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4840 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
4841 return;
4842 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
4843 vn_encode_simple_pointer(enc, pnext);
4844 vn_encode_VkStructureType(enc, &pnext->sType);
4845 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4846 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
4847 return;
4848 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
4849 vn_encode_simple_pointer(enc, pnext);
4850 vn_encode_VkStructureType(enc, &pnext->sType);
4851 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4852 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
4853 return;
4854 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
4855 vn_encode_simple_pointer(enc, pnext);
4856 vn_encode_VkStructureType(enc, &pnext->sType);
4857 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4858 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
4859 return;
4860 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
4861 vn_encode_simple_pointer(enc, pnext);
4862 vn_encode_VkStructureType(enc, &pnext->sType);
4863 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4864 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
4865 return;
4866 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
4867 vn_encode_simple_pointer(enc, pnext);
4868 vn_encode_VkStructureType(enc, &pnext->sType);
4869 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4870 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
4871 return;
4872 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
4873 vn_encode_simple_pointer(enc, pnext);
4874 vn_encode_VkStructureType(enc, &pnext->sType);
4875 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4876 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
4877 return;
4878 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
4879 vn_encode_simple_pointer(enc, pnext);
4880 vn_encode_VkStructureType(enc, &pnext->sType);
4881 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4882 vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, (const VkPhysicalDeviceVulkan11Features *)pnext);
4883 return;
4884 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
4885 vn_encode_simple_pointer(enc, pnext);
4886 vn_encode_VkStructureType(enc, &pnext->sType);
4887 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4888 vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, (const VkPhysicalDeviceVulkan12Features *)pnext);
4889 return;
4890 default:
4891 /* ignore unknown/unsupported struct */
4892 break;
4893 }
4894 pnext = pnext->pNext;
4895 }
4896
4897 vn_encode_simple_pointer(enc, NULL);
4898 }
4899
4900 static inline void
vn_encode_VkPhysicalDeviceFeatures2_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures2 * val)4901 vn_encode_VkPhysicalDeviceFeatures2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
4902 {
4903 /* skip val->{sType,pNext} */
4904 vn_encode_VkPhysicalDeviceFeatures(enc, &val->features);
4905 }
4906
4907 static inline void
vn_encode_VkPhysicalDeviceFeatures2(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures2 * val)4908 vn_encode_VkPhysicalDeviceFeatures2(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
4909 {
4910 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
4911 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 });
4912 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, val->pNext);
4913 vn_encode_VkPhysicalDeviceFeatures2_self(enc, val);
4914 }
4915
4916 static inline void
vn_decode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_decoder * dec,const void * val)4917 vn_decode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_decoder *dec, const void *val)
4918 {
4919 VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
4920 VkStructureType stype;
4921
4922 if (!vn_decode_simple_pointer(dec))
4923 return;
4924
4925 vn_decode_VkStructureType(dec, &stype);
4926 while (true) {
4927 assert(pnext);
4928 if (pnext->sType == stype)
4929 break;
4930 }
4931
4932 switch ((int32_t)pnext->sType) {
4933 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
4934 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4935 vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(dec, (VkPhysicalDeviceVariablePointersFeatures *)pnext);
4936 break;
4937 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
4938 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4939 vn_decode_VkPhysicalDeviceMultiviewFeatures_self(dec, (VkPhysicalDeviceMultiviewFeatures *)pnext);
4940 break;
4941 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
4942 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4943 vn_decode_VkPhysicalDevice16BitStorageFeatures_self(dec, (VkPhysicalDevice16BitStorageFeatures *)pnext);
4944 break;
4945 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
4946 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4947 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(dec, (VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
4948 break;
4949 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
4950 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4951 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(dec, (VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
4952 break;
4953 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
4954 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4955 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(dec, (VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
4956 break;
4957 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
4958 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4959 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(dec, (VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
4960 break;
4961 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
4962 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4963 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(dec, (VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
4964 break;
4965 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
4966 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4967 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(dec, (VkPhysicalDeviceHostQueryResetFeatures *)pnext);
4968 break;
4969 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
4970 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4971 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(dec, (VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
4972 break;
4973 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
4974 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4975 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(dec, (VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
4976 break;
4977 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
4978 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4979 vn_decode_VkPhysicalDevice8BitStorageFeatures_self(dec, (VkPhysicalDevice8BitStorageFeatures *)pnext);
4980 break;
4981 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
4982 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4983 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(dec, (VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
4984 break;
4985 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
4986 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4987 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(dec, (VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
4988 break;
4989 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
4990 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4991 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(dec, (VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
4992 break;
4993 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
4994 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4995 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(dec, (VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
4996 break;
4997 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
4998 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4999 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(dec, (VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
5000 break;
5001 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
5002 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
5003 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(dec, (VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
5004 break;
5005 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
5006 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
5007 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(dec, (VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
5008 break;
5009 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
5010 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
5011 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(dec, (VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
5012 break;
5013 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
5014 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
5015 vn_decode_VkPhysicalDeviceVulkan11Features_self(dec, (VkPhysicalDeviceVulkan11Features *)pnext);
5016 break;
5017 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
5018 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
5019 vn_decode_VkPhysicalDeviceVulkan12Features_self(dec, (VkPhysicalDeviceVulkan12Features *)pnext);
5020 break;
5021 default:
5022 assert(false);
5023 break;
5024 }
5025 }
5026
5027 static inline void
vn_decode_VkPhysicalDeviceFeatures2_self(struct vn_cs_decoder * dec,VkPhysicalDeviceFeatures2 * val)5028 vn_decode_VkPhysicalDeviceFeatures2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures2 *val)
5029 {
5030 /* skip val->{sType,pNext} */
5031 vn_decode_VkPhysicalDeviceFeatures(dec, &val->features);
5032 }
5033
5034 static inline void
vn_decode_VkPhysicalDeviceFeatures2(struct vn_cs_decoder * dec,VkPhysicalDeviceFeatures2 * val)5035 vn_decode_VkPhysicalDeviceFeatures2(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures2 *val)
5036 {
5037 VkStructureType stype;
5038 vn_decode_VkStructureType(dec, &stype);
5039 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
5040
5041 assert(val->sType == stype);
5042 vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, val->pNext);
5043 vn_decode_VkPhysicalDeviceFeatures2_self(dec, val);
5044 }
5045
5046 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(const void * val)5047 vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(const void *val)
5048 {
5049 const VkBaseInStructure *pnext = val;
5050 size_t size = 0;
5051
5052 while (pnext) {
5053 switch ((int32_t)pnext->sType) {
5054 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
5055 size += vn_sizeof_simple_pointer(pnext);
5056 size += vn_sizeof_VkStructureType(&pnext->sType);
5057 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5058 size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial((const VkPhysicalDeviceVariablePointersFeatures *)pnext);
5059 return size;
5060 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
5061 size += vn_sizeof_simple_pointer(pnext);
5062 size += vn_sizeof_VkStructureType(&pnext->sType);
5063 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5064 size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial((const VkPhysicalDeviceMultiviewFeatures *)pnext);
5065 return size;
5066 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
5067 size += vn_sizeof_simple_pointer(pnext);
5068 size += vn_sizeof_VkStructureType(&pnext->sType);
5069 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5070 size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial((const VkPhysicalDevice16BitStorageFeatures *)pnext);
5071 return size;
5072 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
5073 size += vn_sizeof_simple_pointer(pnext);
5074 size += vn_sizeof_VkStructureType(&pnext->sType);
5075 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5076 size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
5077 return size;
5078 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
5079 size += vn_sizeof_simple_pointer(pnext);
5080 size += vn_sizeof_VkStructureType(&pnext->sType);
5081 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5082 size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
5083 return size;
5084 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
5085 size += vn_sizeof_simple_pointer(pnext);
5086 size += vn_sizeof_VkStructureType(&pnext->sType);
5087 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5088 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
5089 return size;
5090 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
5091 size += vn_sizeof_simple_pointer(pnext);
5092 size += vn_sizeof_VkStructureType(&pnext->sType);
5093 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5094 size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
5095 return size;
5096 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
5097 size += vn_sizeof_simple_pointer(pnext);
5098 size += vn_sizeof_VkStructureType(&pnext->sType);
5099 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5100 size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
5101 return size;
5102 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
5103 size += vn_sizeof_simple_pointer(pnext);
5104 size += vn_sizeof_VkStructureType(&pnext->sType);
5105 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5106 size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial((const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
5107 return size;
5108 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
5109 size += vn_sizeof_simple_pointer(pnext);
5110 size += vn_sizeof_VkStructureType(&pnext->sType);
5111 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5112 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
5113 return size;
5114 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
5115 size += vn_sizeof_simple_pointer(pnext);
5116 size += vn_sizeof_VkStructureType(&pnext->sType);
5117 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5118 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
5119 return size;
5120 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
5121 size += vn_sizeof_simple_pointer(pnext);
5122 size += vn_sizeof_VkStructureType(&pnext->sType);
5123 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5124 size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial((const VkPhysicalDevice8BitStorageFeatures *)pnext);
5125 return size;
5126 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
5127 size += vn_sizeof_simple_pointer(pnext);
5128 size += vn_sizeof_VkStructureType(&pnext->sType);
5129 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5130 size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
5131 return size;
5132 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
5133 size += vn_sizeof_simple_pointer(pnext);
5134 size += vn_sizeof_VkStructureType(&pnext->sType);
5135 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5136 size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
5137 return size;
5138 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
5139 size += vn_sizeof_simple_pointer(pnext);
5140 size += vn_sizeof_VkStructureType(&pnext->sType);
5141 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5142 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
5143 return size;
5144 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
5145 size += vn_sizeof_simple_pointer(pnext);
5146 size += vn_sizeof_VkStructureType(&pnext->sType);
5147 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5148 size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
5149 return size;
5150 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
5151 size += vn_sizeof_simple_pointer(pnext);
5152 size += vn_sizeof_VkStructureType(&pnext->sType);
5153 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5154 size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
5155 return size;
5156 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
5157 size += vn_sizeof_simple_pointer(pnext);
5158 size += vn_sizeof_VkStructureType(&pnext->sType);
5159 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5160 size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
5161 return size;
5162 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
5163 size += vn_sizeof_simple_pointer(pnext);
5164 size += vn_sizeof_VkStructureType(&pnext->sType);
5165 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5166 size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
5167 return size;
5168 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
5169 size += vn_sizeof_simple_pointer(pnext);
5170 size += vn_sizeof_VkStructureType(&pnext->sType);
5171 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5172 size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
5173 return size;
5174 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
5175 size += vn_sizeof_simple_pointer(pnext);
5176 size += vn_sizeof_VkStructureType(&pnext->sType);
5177 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5178 size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial((const VkPhysicalDeviceVulkan11Features *)pnext);
5179 return size;
5180 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
5181 size += vn_sizeof_simple_pointer(pnext);
5182 size += vn_sizeof_VkStructureType(&pnext->sType);
5183 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5184 size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial((const VkPhysicalDeviceVulkan12Features *)pnext);
5185 return size;
5186 default:
5187 /* ignore unknown/unsupported struct */
5188 break;
5189 }
5190 pnext = pnext->pNext;
5191 }
5192
5193 return vn_sizeof_simple_pointer(NULL);
5194 }
5195
5196 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_self_partial(const VkPhysicalDeviceFeatures2 * val)5197 vn_sizeof_VkPhysicalDeviceFeatures2_self_partial(const VkPhysicalDeviceFeatures2 *val)
5198 {
5199 size_t size = 0;
5200 /* skip val->{sType,pNext} */
5201 size += vn_sizeof_VkPhysicalDeviceFeatures_partial(&val->features);
5202 return size;
5203 }
5204
5205 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_partial(const VkPhysicalDeviceFeatures2 * val)5206 vn_sizeof_VkPhysicalDeviceFeatures2_partial(const VkPhysicalDeviceFeatures2 *val)
5207 {
5208 size_t size = 0;
5209
5210 size += vn_sizeof_VkStructureType(&val->sType);
5211 size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(val->pNext);
5212 size += vn_sizeof_VkPhysicalDeviceFeatures2_self_partial(val);
5213
5214 return size;
5215 }
5216
5217 static inline void
vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(struct vn_cs_encoder * enc,const void * val)5218 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
5219 {
5220 const VkBaseInStructure *pnext = val;
5221
5222 while (pnext) {
5223 switch ((int32_t)pnext->sType) {
5224 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
5225 vn_encode_simple_pointer(enc, pnext);
5226 vn_encode_VkStructureType(enc, &pnext->sType);
5227 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5228 vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext);
5229 return;
5230 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
5231 vn_encode_simple_pointer(enc, pnext);
5232 vn_encode_VkStructureType(enc, &pnext->sType);
5233 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5234 vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext);
5235 return;
5236 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
5237 vn_encode_simple_pointer(enc, pnext);
5238 vn_encode_VkStructureType(enc, &pnext->sType);
5239 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5240 vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext);
5241 return;
5242 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
5243 vn_encode_simple_pointer(enc, pnext);
5244 vn_encode_VkStructureType(enc, &pnext->sType);
5245 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5246 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
5247 return;
5248 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
5249 vn_encode_simple_pointer(enc, pnext);
5250 vn_encode_VkStructureType(enc, &pnext->sType);
5251 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5252 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
5253 return;
5254 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
5255 vn_encode_simple_pointer(enc, pnext);
5256 vn_encode_VkStructureType(enc, &pnext->sType);
5257 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5258 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
5259 return;
5260 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
5261 vn_encode_simple_pointer(enc, pnext);
5262 vn_encode_VkStructureType(enc, &pnext->sType);
5263 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5264 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
5265 return;
5266 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
5267 vn_encode_simple_pointer(enc, pnext);
5268 vn_encode_VkStructureType(enc, &pnext->sType);
5269 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5270 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
5271 return;
5272 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
5273 vn_encode_simple_pointer(enc, pnext);
5274 vn_encode_VkStructureType(enc, &pnext->sType);
5275 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5276 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
5277 return;
5278 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
5279 vn_encode_simple_pointer(enc, pnext);
5280 vn_encode_VkStructureType(enc, &pnext->sType);
5281 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5282 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
5283 return;
5284 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
5285 vn_encode_simple_pointer(enc, pnext);
5286 vn_encode_VkStructureType(enc, &pnext->sType);
5287 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5288 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
5289 return;
5290 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
5291 vn_encode_simple_pointer(enc, pnext);
5292 vn_encode_VkStructureType(enc, &pnext->sType);
5293 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5294 vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext);
5295 return;
5296 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
5297 vn_encode_simple_pointer(enc, pnext);
5298 vn_encode_VkStructureType(enc, &pnext->sType);
5299 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5300 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
5301 return;
5302 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
5303 vn_encode_simple_pointer(enc, pnext);
5304 vn_encode_VkStructureType(enc, &pnext->sType);
5305 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5306 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
5307 return;
5308 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
5309 vn_encode_simple_pointer(enc, pnext);
5310 vn_encode_VkStructureType(enc, &pnext->sType);
5311 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5312 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
5313 return;
5314 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
5315 vn_encode_simple_pointer(enc, pnext);
5316 vn_encode_VkStructureType(enc, &pnext->sType);
5317 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5318 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
5319 return;
5320 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
5321 vn_encode_simple_pointer(enc, pnext);
5322 vn_encode_VkStructureType(enc, &pnext->sType);
5323 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5324 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
5325 return;
5326 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
5327 vn_encode_simple_pointer(enc, pnext);
5328 vn_encode_VkStructureType(enc, &pnext->sType);
5329 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5330 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
5331 return;
5332 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
5333 vn_encode_simple_pointer(enc, pnext);
5334 vn_encode_VkStructureType(enc, &pnext->sType);
5335 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5336 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
5337 return;
5338 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
5339 vn_encode_simple_pointer(enc, pnext);
5340 vn_encode_VkStructureType(enc, &pnext->sType);
5341 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5342 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
5343 return;
5344 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
5345 vn_encode_simple_pointer(enc, pnext);
5346 vn_encode_VkStructureType(enc, &pnext->sType);
5347 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5348 vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(enc, (const VkPhysicalDeviceVulkan11Features *)pnext);
5349 return;
5350 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
5351 vn_encode_simple_pointer(enc, pnext);
5352 vn_encode_VkStructureType(enc, &pnext->sType);
5353 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5354 vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(enc, (const VkPhysicalDeviceVulkan12Features *)pnext);
5355 return;
5356 default:
5357 /* ignore unknown/unsupported struct */
5358 break;
5359 }
5360 pnext = pnext->pNext;
5361 }
5362
5363 vn_encode_simple_pointer(enc, NULL);
5364 }
5365
5366 static inline void
vn_encode_VkPhysicalDeviceFeatures2_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures2 * val)5367 vn_encode_VkPhysicalDeviceFeatures2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
5368 {
5369 /* skip val->{sType,pNext} */
5370 vn_encode_VkPhysicalDeviceFeatures_partial(enc, &val->features);
5371 }
5372
5373 static inline void
vn_encode_VkPhysicalDeviceFeatures2_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures2 * val)5374 vn_encode_VkPhysicalDeviceFeatures2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
5375 {
5376 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
5377 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 });
5378 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, val->pNext);
5379 vn_encode_VkPhysicalDeviceFeatures2_self_partial(enc, val);
5380 }
5381
5382 /* struct VkDeviceGroupDeviceCreateInfo chain */
5383
5384 static inline size_t
vn_sizeof_VkDeviceGroupDeviceCreateInfo_pnext(const void * val)5385 vn_sizeof_VkDeviceGroupDeviceCreateInfo_pnext(const void *val)
5386 {
5387 /* no known/supported struct */
5388 return vn_sizeof_simple_pointer(NULL);
5389 }
5390
5391 static inline size_t
vn_sizeof_VkDeviceGroupDeviceCreateInfo_self(const VkDeviceGroupDeviceCreateInfo * val)5392 vn_sizeof_VkDeviceGroupDeviceCreateInfo_self(const VkDeviceGroupDeviceCreateInfo *val)
5393 {
5394 size_t size = 0;
5395 /* skip val->{sType,pNext} */
5396 size += vn_sizeof_uint32_t(&val->physicalDeviceCount);
5397 if (val->pPhysicalDevices) {
5398 size += vn_sizeof_array_size(val->physicalDeviceCount);
5399 for (uint32_t i = 0; i < val->physicalDeviceCount; i++)
5400 size += vn_sizeof_VkPhysicalDevice(&val->pPhysicalDevices[i]);
5401 } else {
5402 size += vn_sizeof_array_size(0);
5403 }
5404 return size;
5405 }
5406
5407 static inline size_t
vn_sizeof_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo * val)5408 vn_sizeof_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo *val)
5409 {
5410 size_t size = 0;
5411
5412 size += vn_sizeof_VkStructureType(&val->sType);
5413 size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_pnext(val->pNext);
5414 size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_self(val);
5415
5416 return size;
5417 }
5418
5419 static inline void
vn_encode_VkDeviceGroupDeviceCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)5420 vn_encode_VkDeviceGroupDeviceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
5421 {
5422 /* no known/supported struct */
5423 vn_encode_simple_pointer(enc, NULL);
5424 }
5425
5426 static inline void
vn_encode_VkDeviceGroupDeviceCreateInfo_self(struct vn_cs_encoder * enc,const VkDeviceGroupDeviceCreateInfo * val)5427 vn_encode_VkDeviceGroupDeviceCreateInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupDeviceCreateInfo *val)
5428 {
5429 /* skip val->{sType,pNext} */
5430 vn_encode_uint32_t(enc, &val->physicalDeviceCount);
5431 if (val->pPhysicalDevices) {
5432 vn_encode_array_size(enc, val->physicalDeviceCount);
5433 for (uint32_t i = 0; i < val->physicalDeviceCount; i++)
5434 vn_encode_VkPhysicalDevice(enc, &val->pPhysicalDevices[i]);
5435 } else {
5436 vn_encode_array_size(enc, 0);
5437 }
5438 }
5439
5440 static inline void
vn_encode_VkDeviceGroupDeviceCreateInfo(struct vn_cs_encoder * enc,const VkDeviceGroupDeviceCreateInfo * val)5441 vn_encode_VkDeviceGroupDeviceCreateInfo(struct vn_cs_encoder *enc, const VkDeviceGroupDeviceCreateInfo *val)
5442 {
5443 assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO);
5444 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO });
5445 vn_encode_VkDeviceGroupDeviceCreateInfo_pnext(enc, val->pNext);
5446 vn_encode_VkDeviceGroupDeviceCreateInfo_self(enc, val);
5447 }
5448
5449 /* struct VkDeviceCreateInfo chain */
5450
5451 static inline size_t
vn_sizeof_VkDeviceCreateInfo_pnext(const void * val)5452 vn_sizeof_VkDeviceCreateInfo_pnext(const void *val)
5453 {
5454 const VkBaseInStructure *pnext = val;
5455 size_t size = 0;
5456
5457 while (pnext) {
5458 switch ((int32_t)pnext->sType) {
5459 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
5460 size += vn_sizeof_simple_pointer(pnext);
5461 size += vn_sizeof_VkStructureType(&pnext->sType);
5462 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5463 size += vn_sizeof_VkPhysicalDeviceFeatures2_self((const VkPhysicalDeviceFeatures2 *)pnext);
5464 return size;
5465 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
5466 size += vn_sizeof_simple_pointer(pnext);
5467 size += vn_sizeof_VkStructureType(&pnext->sType);
5468 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5469 size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self((const VkPhysicalDeviceVariablePointersFeatures *)pnext);
5470 return size;
5471 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
5472 size += vn_sizeof_simple_pointer(pnext);
5473 size += vn_sizeof_VkStructureType(&pnext->sType);
5474 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5475 size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self((const VkPhysicalDeviceMultiviewFeatures *)pnext);
5476 return size;
5477 case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
5478 size += vn_sizeof_simple_pointer(pnext);
5479 size += vn_sizeof_VkStructureType(&pnext->sType);
5480 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5481 size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_self((const VkDeviceGroupDeviceCreateInfo *)pnext);
5482 return size;
5483 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
5484 size += vn_sizeof_simple_pointer(pnext);
5485 size += vn_sizeof_VkStructureType(&pnext->sType);
5486 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5487 size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self((const VkPhysicalDevice16BitStorageFeatures *)pnext);
5488 return size;
5489 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
5490 size += vn_sizeof_simple_pointer(pnext);
5491 size += vn_sizeof_VkStructureType(&pnext->sType);
5492 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5493 size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
5494 return size;
5495 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
5496 size += vn_sizeof_simple_pointer(pnext);
5497 size += vn_sizeof_VkStructureType(&pnext->sType);
5498 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5499 size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
5500 return size;
5501 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
5502 size += vn_sizeof_simple_pointer(pnext);
5503 size += vn_sizeof_VkStructureType(&pnext->sType);
5504 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5505 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
5506 return size;
5507 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
5508 size += vn_sizeof_simple_pointer(pnext);
5509 size += vn_sizeof_VkStructureType(&pnext->sType);
5510 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5511 size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
5512 return size;
5513 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
5514 size += vn_sizeof_simple_pointer(pnext);
5515 size += vn_sizeof_VkStructureType(&pnext->sType);
5516 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5517 size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
5518 return size;
5519 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
5520 size += vn_sizeof_simple_pointer(pnext);
5521 size += vn_sizeof_VkStructureType(&pnext->sType);
5522 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5523 size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self((const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
5524 return size;
5525 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
5526 size += vn_sizeof_simple_pointer(pnext);
5527 size += vn_sizeof_VkStructureType(&pnext->sType);
5528 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5529 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
5530 return size;
5531 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
5532 size += vn_sizeof_simple_pointer(pnext);
5533 size += vn_sizeof_VkStructureType(&pnext->sType);
5534 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5535 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
5536 return size;
5537 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
5538 size += vn_sizeof_simple_pointer(pnext);
5539 size += vn_sizeof_VkStructureType(&pnext->sType);
5540 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5541 size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self((const VkPhysicalDevice8BitStorageFeatures *)pnext);
5542 return size;
5543 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
5544 size += vn_sizeof_simple_pointer(pnext);
5545 size += vn_sizeof_VkStructureType(&pnext->sType);
5546 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5547 size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
5548 return size;
5549 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
5550 size += vn_sizeof_simple_pointer(pnext);
5551 size += vn_sizeof_VkStructureType(&pnext->sType);
5552 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5553 size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
5554 return size;
5555 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
5556 size += vn_sizeof_simple_pointer(pnext);
5557 size += vn_sizeof_VkStructureType(&pnext->sType);
5558 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5559 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
5560 return size;
5561 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
5562 size += vn_sizeof_simple_pointer(pnext);
5563 size += vn_sizeof_VkStructureType(&pnext->sType);
5564 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5565 size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
5566 return size;
5567 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
5568 size += vn_sizeof_simple_pointer(pnext);
5569 size += vn_sizeof_VkStructureType(&pnext->sType);
5570 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5571 size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
5572 return size;
5573 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
5574 size += vn_sizeof_simple_pointer(pnext);
5575 size += vn_sizeof_VkStructureType(&pnext->sType);
5576 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5577 size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
5578 return size;
5579 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
5580 size += vn_sizeof_simple_pointer(pnext);
5581 size += vn_sizeof_VkStructureType(&pnext->sType);
5582 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5583 size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
5584 return size;
5585 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
5586 size += vn_sizeof_simple_pointer(pnext);
5587 size += vn_sizeof_VkStructureType(&pnext->sType);
5588 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5589 size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
5590 return size;
5591 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
5592 size += vn_sizeof_simple_pointer(pnext);
5593 size += vn_sizeof_VkStructureType(&pnext->sType);
5594 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5595 size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self((const VkPhysicalDeviceVulkan11Features *)pnext);
5596 return size;
5597 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
5598 size += vn_sizeof_simple_pointer(pnext);
5599 size += vn_sizeof_VkStructureType(&pnext->sType);
5600 size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5601 size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self((const VkPhysicalDeviceVulkan12Features *)pnext);
5602 return size;
5603 default:
5604 /* ignore unknown/unsupported struct */
5605 break;
5606 }
5607 pnext = pnext->pNext;
5608 }
5609
5610 return vn_sizeof_simple_pointer(NULL);
5611 }
5612
5613 static inline size_t
vn_sizeof_VkDeviceCreateInfo_self(const VkDeviceCreateInfo * val)5614 vn_sizeof_VkDeviceCreateInfo_self(const VkDeviceCreateInfo *val)
5615 {
5616 size_t size = 0;
5617 /* skip val->{sType,pNext} */
5618 size += vn_sizeof_VkFlags(&val->flags);
5619 size += vn_sizeof_uint32_t(&val->queueCreateInfoCount);
5620 if (val->pQueueCreateInfos) {
5621 size += vn_sizeof_array_size(val->queueCreateInfoCount);
5622 for (uint32_t i = 0; i < val->queueCreateInfoCount; i++)
5623 size += vn_sizeof_VkDeviceQueueCreateInfo(&val->pQueueCreateInfos[i]);
5624 } else {
5625 size += vn_sizeof_array_size(0);
5626 }
5627 size += vn_sizeof_uint32_t(&val->enabledLayerCount);
5628 if (val->ppEnabledLayerNames) {
5629 size += vn_sizeof_array_size(val->enabledLayerCount);
5630 for (uint32_t i = 0; i < val->enabledLayerCount; i++) {
5631 const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1;
5632 size += vn_sizeof_array_size(string_size);
5633 size += vn_sizeof_char_array(val->ppEnabledLayerNames[i], string_size);
5634 }
5635 } else {
5636 size += vn_sizeof_array_size(0);
5637 }
5638 size += vn_sizeof_uint32_t(&val->enabledExtensionCount);
5639 if (val->ppEnabledExtensionNames) {
5640 size += vn_sizeof_array_size(val->enabledExtensionCount);
5641 for (uint32_t i = 0; i < val->enabledExtensionCount; i++) {
5642 const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1;
5643 size += vn_sizeof_array_size(string_size);
5644 size += vn_sizeof_char_array(val->ppEnabledExtensionNames[i], string_size);
5645 }
5646 } else {
5647 size += vn_sizeof_array_size(0);
5648 }
5649 size += vn_sizeof_simple_pointer(val->pEnabledFeatures);
5650 if (val->pEnabledFeatures)
5651 size += vn_sizeof_VkPhysicalDeviceFeatures(val->pEnabledFeatures);
5652 return size;
5653 }
5654
5655 static inline size_t
vn_sizeof_VkDeviceCreateInfo(const VkDeviceCreateInfo * val)5656 vn_sizeof_VkDeviceCreateInfo(const VkDeviceCreateInfo *val)
5657 {
5658 size_t size = 0;
5659
5660 size += vn_sizeof_VkStructureType(&val->sType);
5661 size += vn_sizeof_VkDeviceCreateInfo_pnext(val->pNext);
5662 size += vn_sizeof_VkDeviceCreateInfo_self(val);
5663
5664 return size;
5665 }
5666
5667 static inline void
vn_encode_VkDeviceCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)5668 vn_encode_VkDeviceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
5669 {
5670 const VkBaseInStructure *pnext = val;
5671
5672 while (pnext) {
5673 switch ((int32_t)pnext->sType) {
5674 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
5675 vn_encode_simple_pointer(enc, pnext);
5676 vn_encode_VkStructureType(enc, &pnext->sType);
5677 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5678 vn_encode_VkPhysicalDeviceFeatures2_self(enc, (const VkPhysicalDeviceFeatures2 *)pnext);
5679 return;
5680 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
5681 vn_encode_simple_pointer(enc, pnext);
5682 vn_encode_VkStructureType(enc, &pnext->sType);
5683 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5684 vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext);
5685 return;
5686 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
5687 vn_encode_simple_pointer(enc, pnext);
5688 vn_encode_VkStructureType(enc, &pnext->sType);
5689 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5690 vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext);
5691 return;
5692 case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
5693 vn_encode_simple_pointer(enc, pnext);
5694 vn_encode_VkStructureType(enc, &pnext->sType);
5695 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5696 vn_encode_VkDeviceGroupDeviceCreateInfo_self(enc, (const VkDeviceGroupDeviceCreateInfo *)pnext);
5697 return;
5698 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
5699 vn_encode_simple_pointer(enc, pnext);
5700 vn_encode_VkStructureType(enc, &pnext->sType);
5701 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5702 vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext);
5703 return;
5704 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
5705 vn_encode_simple_pointer(enc, pnext);
5706 vn_encode_VkStructureType(enc, &pnext->sType);
5707 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5708 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
5709 return;
5710 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
5711 vn_encode_simple_pointer(enc, pnext);
5712 vn_encode_VkStructureType(enc, &pnext->sType);
5713 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5714 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
5715 return;
5716 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
5717 vn_encode_simple_pointer(enc, pnext);
5718 vn_encode_VkStructureType(enc, &pnext->sType);
5719 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5720 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
5721 return;
5722 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
5723 vn_encode_simple_pointer(enc, pnext);
5724 vn_encode_VkStructureType(enc, &pnext->sType);
5725 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5726 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
5727 return;
5728 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
5729 vn_encode_simple_pointer(enc, pnext);
5730 vn_encode_VkStructureType(enc, &pnext->sType);
5731 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5732 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
5733 return;
5734 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
5735 vn_encode_simple_pointer(enc, pnext);
5736 vn_encode_VkStructureType(enc, &pnext->sType);
5737 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5738 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
5739 return;
5740 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
5741 vn_encode_simple_pointer(enc, pnext);
5742 vn_encode_VkStructureType(enc, &pnext->sType);
5743 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5744 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
5745 return;
5746 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
5747 vn_encode_simple_pointer(enc, pnext);
5748 vn_encode_VkStructureType(enc, &pnext->sType);
5749 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5750 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
5751 return;
5752 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
5753 vn_encode_simple_pointer(enc, pnext);
5754 vn_encode_VkStructureType(enc, &pnext->sType);
5755 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5756 vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext);
5757 return;
5758 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
5759 vn_encode_simple_pointer(enc, pnext);
5760 vn_encode_VkStructureType(enc, &pnext->sType);
5761 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5762 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
5763 return;
5764 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
5765 vn_encode_simple_pointer(enc, pnext);
5766 vn_encode_VkStructureType(enc, &pnext->sType);
5767 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5768 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
5769 return;
5770 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
5771 vn_encode_simple_pointer(enc, pnext);
5772 vn_encode_VkStructureType(enc, &pnext->sType);
5773 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5774 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
5775 return;
5776 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
5777 vn_encode_simple_pointer(enc, pnext);
5778 vn_encode_VkStructureType(enc, &pnext->sType);
5779 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5780 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
5781 return;
5782 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
5783 vn_encode_simple_pointer(enc, pnext);
5784 vn_encode_VkStructureType(enc, &pnext->sType);
5785 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5786 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
5787 return;
5788 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
5789 vn_encode_simple_pointer(enc, pnext);
5790 vn_encode_VkStructureType(enc, &pnext->sType);
5791 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5792 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
5793 return;
5794 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
5795 vn_encode_simple_pointer(enc, pnext);
5796 vn_encode_VkStructureType(enc, &pnext->sType);
5797 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5798 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
5799 return;
5800 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
5801 vn_encode_simple_pointer(enc, pnext);
5802 vn_encode_VkStructureType(enc, &pnext->sType);
5803 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5804 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
5805 return;
5806 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
5807 vn_encode_simple_pointer(enc, pnext);
5808 vn_encode_VkStructureType(enc, &pnext->sType);
5809 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5810 vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, (const VkPhysicalDeviceVulkan11Features *)pnext);
5811 return;
5812 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
5813 vn_encode_simple_pointer(enc, pnext);
5814 vn_encode_VkStructureType(enc, &pnext->sType);
5815 vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5816 vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, (const VkPhysicalDeviceVulkan12Features *)pnext);
5817 return;
5818 default:
5819 /* ignore unknown/unsupported struct */
5820 break;
5821 }
5822 pnext = pnext->pNext;
5823 }
5824
5825 vn_encode_simple_pointer(enc, NULL);
5826 }
5827
5828 static inline void
vn_encode_VkDeviceCreateInfo_self(struct vn_cs_encoder * enc,const VkDeviceCreateInfo * val)5829 vn_encode_VkDeviceCreateInfo_self(struct vn_cs_encoder *enc, const VkDeviceCreateInfo *val)
5830 {
5831 /* skip val->{sType,pNext} */
5832 vn_encode_VkFlags(enc, &val->flags);
5833 vn_encode_uint32_t(enc, &val->queueCreateInfoCount);
5834 if (val->pQueueCreateInfos) {
5835 vn_encode_array_size(enc, val->queueCreateInfoCount);
5836 for (uint32_t i = 0; i < val->queueCreateInfoCount; i++)
5837 vn_encode_VkDeviceQueueCreateInfo(enc, &val->pQueueCreateInfos[i]);
5838 } else {
5839 vn_encode_array_size(enc, 0);
5840 }
5841 vn_encode_uint32_t(enc, &val->enabledLayerCount);
5842 if (val->ppEnabledLayerNames) {
5843 vn_encode_array_size(enc, val->enabledLayerCount);
5844 for (uint32_t i = 0; i < val->enabledLayerCount; i++) {
5845 const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1;
5846 vn_encode_array_size(enc, string_size);
5847 vn_encode_char_array(enc, val->ppEnabledLayerNames[i], string_size);
5848 }
5849 } else {
5850 vn_encode_array_size(enc, 0);
5851 }
5852 vn_encode_uint32_t(enc, &val->enabledExtensionCount);
5853 if (val->ppEnabledExtensionNames) {
5854 vn_encode_array_size(enc, val->enabledExtensionCount);
5855 for (uint32_t i = 0; i < val->enabledExtensionCount; i++) {
5856 const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1;
5857 vn_encode_array_size(enc, string_size);
5858 vn_encode_char_array(enc, val->ppEnabledExtensionNames[i], string_size);
5859 }
5860 } else {
5861 vn_encode_array_size(enc, 0);
5862 }
5863 if (vn_encode_simple_pointer(enc, val->pEnabledFeatures))
5864 vn_encode_VkPhysicalDeviceFeatures(enc, val->pEnabledFeatures);
5865 }
5866
5867 static inline void
vn_encode_VkDeviceCreateInfo(struct vn_cs_encoder * enc,const VkDeviceCreateInfo * val)5868 vn_encode_VkDeviceCreateInfo(struct vn_cs_encoder *enc, const VkDeviceCreateInfo *val)
5869 {
5870 assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO);
5871 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO });
5872 vn_encode_VkDeviceCreateInfo_pnext(enc, val->pNext);
5873 vn_encode_VkDeviceCreateInfo_self(enc, val);
5874 }
5875
5876 /* struct VkConformanceVersion */
5877
5878 static inline size_t
vn_sizeof_VkConformanceVersion(const VkConformanceVersion * val)5879 vn_sizeof_VkConformanceVersion(const VkConformanceVersion *val)
5880 {
5881 size_t size = 0;
5882 size += vn_sizeof_uint8_t(&val->major);
5883 size += vn_sizeof_uint8_t(&val->minor);
5884 size += vn_sizeof_uint8_t(&val->subminor);
5885 size += vn_sizeof_uint8_t(&val->patch);
5886 return size;
5887 }
5888
5889 static inline void
vn_decode_VkConformanceVersion(struct vn_cs_decoder * dec,VkConformanceVersion * val)5890 vn_decode_VkConformanceVersion(struct vn_cs_decoder *dec, VkConformanceVersion *val)
5891 {
5892 vn_decode_uint8_t(dec, &val->major);
5893 vn_decode_uint8_t(dec, &val->minor);
5894 vn_decode_uint8_t(dec, &val->subminor);
5895 vn_decode_uint8_t(dec, &val->patch);
5896 }
5897
5898 static inline size_t
vn_sizeof_VkConformanceVersion_partial(const VkConformanceVersion * val)5899 vn_sizeof_VkConformanceVersion_partial(const VkConformanceVersion *val)
5900 {
5901 size_t size = 0;
5902 /* skip val->major */
5903 /* skip val->minor */
5904 /* skip val->subminor */
5905 /* skip val->patch */
5906 return size;
5907 }
5908
5909 static inline void
vn_encode_VkConformanceVersion_partial(struct vn_cs_encoder * enc,const VkConformanceVersion * val)5910 vn_encode_VkConformanceVersion_partial(struct vn_cs_encoder *enc, const VkConformanceVersion *val)
5911 {
5912 /* skip val->major */
5913 /* skip val->minor */
5914 /* skip val->subminor */
5915 /* skip val->patch */
5916 }
5917
5918 /* struct VkPhysicalDeviceDriverProperties chain */
5919
5920 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_pnext(const void * val)5921 vn_sizeof_VkPhysicalDeviceDriverProperties_pnext(const void *val)
5922 {
5923 /* no known/supported struct */
5924 return vn_sizeof_simple_pointer(NULL);
5925 }
5926
5927 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_self(const VkPhysicalDeviceDriverProperties * val)5928 vn_sizeof_VkPhysicalDeviceDriverProperties_self(const VkPhysicalDeviceDriverProperties *val)
5929 {
5930 size_t size = 0;
5931 /* skip val->{sType,pNext} */
5932 size += vn_sizeof_VkDriverId(&val->driverID);
5933 size += vn_sizeof_array_size(VK_MAX_DRIVER_NAME_SIZE);
5934 size += vn_sizeof_char_array(val->driverName, VK_MAX_DRIVER_NAME_SIZE);
5935 size += vn_sizeof_array_size(VK_MAX_DRIVER_INFO_SIZE);
5936 size += vn_sizeof_char_array(val->driverInfo, VK_MAX_DRIVER_INFO_SIZE);
5937 size += vn_sizeof_VkConformanceVersion(&val->conformanceVersion);
5938 return size;
5939 }
5940
5941 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties * val)5942 vn_sizeof_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties *val)
5943 {
5944 size_t size = 0;
5945
5946 size += vn_sizeof_VkStructureType(&val->sType);
5947 size += vn_sizeof_VkPhysicalDeviceDriverProperties_pnext(val->pNext);
5948 size += vn_sizeof_VkPhysicalDeviceDriverProperties_self(val);
5949
5950 return size;
5951 }
5952
5953 static inline void
vn_decode_VkPhysicalDeviceDriverProperties_pnext(struct vn_cs_decoder * dec,const void * val)5954 vn_decode_VkPhysicalDeviceDriverProperties_pnext(struct vn_cs_decoder *dec, const void *val)
5955 {
5956 /* no known/supported struct */
5957 if (vn_decode_simple_pointer(dec))
5958 assert(false);
5959 }
5960
5961 static inline void
vn_decode_VkPhysicalDeviceDriverProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDriverProperties * val)5962 vn_decode_VkPhysicalDeviceDriverProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDriverProperties *val)
5963 {
5964 /* skip val->{sType,pNext} */
5965 vn_decode_VkDriverId(dec, &val->driverID);
5966 {
5967 const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_NAME_SIZE);
5968 vn_decode_char_array(dec, val->driverName, array_size);
5969 }
5970 {
5971 const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_INFO_SIZE);
5972 vn_decode_char_array(dec, val->driverInfo, array_size);
5973 }
5974 vn_decode_VkConformanceVersion(dec, &val->conformanceVersion);
5975 }
5976
5977 static inline void
vn_decode_VkPhysicalDeviceDriverProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceDriverProperties * val)5978 vn_decode_VkPhysicalDeviceDriverProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDriverProperties *val)
5979 {
5980 VkStructureType stype;
5981 vn_decode_VkStructureType(dec, &stype);
5982 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
5983
5984 assert(val->sType == stype);
5985 vn_decode_VkPhysicalDeviceDriverProperties_pnext(dec, val->pNext);
5986 vn_decode_VkPhysicalDeviceDriverProperties_self(dec, val);
5987 }
5988
5989 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_pnext_partial(const void * val)5990 vn_sizeof_VkPhysicalDeviceDriverProperties_pnext_partial(const void *val)
5991 {
5992 /* no known/supported struct */
5993 return vn_sizeof_simple_pointer(NULL);
5994 }
5995
5996 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial(const VkPhysicalDeviceDriverProperties * val)5997 vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial(const VkPhysicalDeviceDriverProperties *val)
5998 {
5999 size_t size = 0;
6000 /* skip val->{sType,pNext} */
6001 /* skip val->driverID */
6002 /* skip val->driverName */
6003 /* skip val->driverInfo */
6004 size += vn_sizeof_VkConformanceVersion_partial(&val->conformanceVersion);
6005 return size;
6006 }
6007
6008 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_partial(const VkPhysicalDeviceDriverProperties * val)6009 vn_sizeof_VkPhysicalDeviceDriverProperties_partial(const VkPhysicalDeviceDriverProperties *val)
6010 {
6011 size_t size = 0;
6012
6013 size += vn_sizeof_VkStructureType(&val->sType);
6014 size += vn_sizeof_VkPhysicalDeviceDriverProperties_pnext_partial(val->pNext);
6015 size += vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial(val);
6016
6017 return size;
6018 }
6019
6020 static inline void
vn_encode_VkPhysicalDeviceDriverProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)6021 vn_encode_VkPhysicalDeviceDriverProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6022 {
6023 /* no known/supported struct */
6024 vn_encode_simple_pointer(enc, NULL);
6025 }
6026
6027 static inline void
vn_encode_VkPhysicalDeviceDriverProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDriverProperties * val)6028 vn_encode_VkPhysicalDeviceDriverProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDriverProperties *val)
6029 {
6030 /* skip val->{sType,pNext} */
6031 /* skip val->driverID */
6032 /* skip val->driverName */
6033 /* skip val->driverInfo */
6034 vn_encode_VkConformanceVersion_partial(enc, &val->conformanceVersion);
6035 }
6036
6037 static inline void
vn_encode_VkPhysicalDeviceDriverProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDriverProperties * val)6038 vn_encode_VkPhysicalDeviceDriverProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDriverProperties *val)
6039 {
6040 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
6041 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES });
6042 vn_encode_VkPhysicalDeviceDriverProperties_pnext_partial(enc, val->pNext);
6043 vn_encode_VkPhysicalDeviceDriverProperties_self_partial(enc, val);
6044 }
6045
6046 /* struct VkPhysicalDeviceIDProperties chain */
6047
6048 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_pnext(const void * val)6049 vn_sizeof_VkPhysicalDeviceIDProperties_pnext(const void *val)
6050 {
6051 /* no known/supported struct */
6052 return vn_sizeof_simple_pointer(NULL);
6053 }
6054
6055 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_self(const VkPhysicalDeviceIDProperties * val)6056 vn_sizeof_VkPhysicalDeviceIDProperties_self(const VkPhysicalDeviceIDProperties *val)
6057 {
6058 size_t size = 0;
6059 /* skip val->{sType,pNext} */
6060 size += vn_sizeof_array_size(VK_UUID_SIZE);
6061 size += vn_sizeof_uint8_t_array(val->deviceUUID, VK_UUID_SIZE);
6062 size += vn_sizeof_array_size(VK_UUID_SIZE);
6063 size += vn_sizeof_uint8_t_array(val->driverUUID, VK_UUID_SIZE);
6064 size += vn_sizeof_array_size(VK_LUID_SIZE);
6065 size += vn_sizeof_uint8_t_array(val->deviceLUID, VK_LUID_SIZE);
6066 size += vn_sizeof_uint32_t(&val->deviceNodeMask);
6067 size += vn_sizeof_VkBool32(&val->deviceLUIDValid);
6068 return size;
6069 }
6070
6071 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties * val)6072 vn_sizeof_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties *val)
6073 {
6074 size_t size = 0;
6075
6076 size += vn_sizeof_VkStructureType(&val->sType);
6077 size += vn_sizeof_VkPhysicalDeviceIDProperties_pnext(val->pNext);
6078 size += vn_sizeof_VkPhysicalDeviceIDProperties_self(val);
6079
6080 return size;
6081 }
6082
6083 static inline void
vn_decode_VkPhysicalDeviceIDProperties_pnext(struct vn_cs_decoder * dec,const void * val)6084 vn_decode_VkPhysicalDeviceIDProperties_pnext(struct vn_cs_decoder *dec, const void *val)
6085 {
6086 /* no known/supported struct */
6087 if (vn_decode_simple_pointer(dec))
6088 assert(false);
6089 }
6090
6091 static inline void
vn_decode_VkPhysicalDeviceIDProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceIDProperties * val)6092 vn_decode_VkPhysicalDeviceIDProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceIDProperties *val)
6093 {
6094 /* skip val->{sType,pNext} */
6095 {
6096 const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
6097 vn_decode_uint8_t_array(dec, val->deviceUUID, array_size);
6098 }
6099 {
6100 const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
6101 vn_decode_uint8_t_array(dec, val->driverUUID, array_size);
6102 }
6103 {
6104 const size_t array_size = vn_decode_array_size(dec, VK_LUID_SIZE);
6105 vn_decode_uint8_t_array(dec, val->deviceLUID, array_size);
6106 }
6107 vn_decode_uint32_t(dec, &val->deviceNodeMask);
6108 vn_decode_VkBool32(dec, &val->deviceLUIDValid);
6109 }
6110
6111 static inline void
vn_decode_VkPhysicalDeviceIDProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceIDProperties * val)6112 vn_decode_VkPhysicalDeviceIDProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceIDProperties *val)
6113 {
6114 VkStructureType stype;
6115 vn_decode_VkStructureType(dec, &stype);
6116 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
6117
6118 assert(val->sType == stype);
6119 vn_decode_VkPhysicalDeviceIDProperties_pnext(dec, val->pNext);
6120 vn_decode_VkPhysicalDeviceIDProperties_self(dec, val);
6121 }
6122
6123 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_pnext_partial(const void * val)6124 vn_sizeof_VkPhysicalDeviceIDProperties_pnext_partial(const void *val)
6125 {
6126 /* no known/supported struct */
6127 return vn_sizeof_simple_pointer(NULL);
6128 }
6129
6130 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_self_partial(const VkPhysicalDeviceIDProperties * val)6131 vn_sizeof_VkPhysicalDeviceIDProperties_self_partial(const VkPhysicalDeviceIDProperties *val)
6132 {
6133 size_t size = 0;
6134 /* skip val->{sType,pNext} */
6135 /* skip val->deviceUUID */
6136 /* skip val->driverUUID */
6137 /* skip val->deviceLUID */
6138 /* skip val->deviceNodeMask */
6139 /* skip val->deviceLUIDValid */
6140 return size;
6141 }
6142
6143 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_partial(const VkPhysicalDeviceIDProperties * val)6144 vn_sizeof_VkPhysicalDeviceIDProperties_partial(const VkPhysicalDeviceIDProperties *val)
6145 {
6146 size_t size = 0;
6147
6148 size += vn_sizeof_VkStructureType(&val->sType);
6149 size += vn_sizeof_VkPhysicalDeviceIDProperties_pnext_partial(val->pNext);
6150 size += vn_sizeof_VkPhysicalDeviceIDProperties_self_partial(val);
6151
6152 return size;
6153 }
6154
6155 static inline void
vn_encode_VkPhysicalDeviceIDProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)6156 vn_encode_VkPhysicalDeviceIDProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6157 {
6158 /* no known/supported struct */
6159 vn_encode_simple_pointer(enc, NULL);
6160 }
6161
6162 static inline void
vn_encode_VkPhysicalDeviceIDProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceIDProperties * val)6163 vn_encode_VkPhysicalDeviceIDProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceIDProperties *val)
6164 {
6165 /* skip val->{sType,pNext} */
6166 /* skip val->deviceUUID */
6167 /* skip val->driverUUID */
6168 /* skip val->deviceLUID */
6169 /* skip val->deviceNodeMask */
6170 /* skip val->deviceLUIDValid */
6171 }
6172
6173 static inline void
vn_encode_VkPhysicalDeviceIDProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceIDProperties * val)6174 vn_encode_VkPhysicalDeviceIDProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceIDProperties *val)
6175 {
6176 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
6177 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES });
6178 vn_encode_VkPhysicalDeviceIDProperties_pnext_partial(enc, val->pNext);
6179 vn_encode_VkPhysicalDeviceIDProperties_self_partial(enc, val);
6180 }
6181
6182 /* struct VkPhysicalDeviceMultiviewProperties chain */
6183
6184 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext(const void * val)6185 vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext(const void *val)
6186 {
6187 /* no known/supported struct */
6188 return vn_sizeof_simple_pointer(NULL);
6189 }
6190
6191 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_self(const VkPhysicalDeviceMultiviewProperties * val)6192 vn_sizeof_VkPhysicalDeviceMultiviewProperties_self(const VkPhysicalDeviceMultiviewProperties *val)
6193 {
6194 size_t size = 0;
6195 /* skip val->{sType,pNext} */
6196 size += vn_sizeof_uint32_t(&val->maxMultiviewViewCount);
6197 size += vn_sizeof_uint32_t(&val->maxMultiviewInstanceIndex);
6198 return size;
6199 }
6200
6201 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties * val)6202 vn_sizeof_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties *val)
6203 {
6204 size_t size = 0;
6205
6206 size += vn_sizeof_VkStructureType(&val->sType);
6207 size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext(val->pNext);
6208 size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self(val);
6209
6210 return size;
6211 }
6212
6213 static inline void
vn_decode_VkPhysicalDeviceMultiviewProperties_pnext(struct vn_cs_decoder * dec,const void * val)6214 vn_decode_VkPhysicalDeviceMultiviewProperties_pnext(struct vn_cs_decoder *dec, const void *val)
6215 {
6216 /* no known/supported struct */
6217 if (vn_decode_simple_pointer(dec))
6218 assert(false);
6219 }
6220
6221 static inline void
vn_decode_VkPhysicalDeviceMultiviewProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewProperties * val)6222 vn_decode_VkPhysicalDeviceMultiviewProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewProperties *val)
6223 {
6224 /* skip val->{sType,pNext} */
6225 vn_decode_uint32_t(dec, &val->maxMultiviewViewCount);
6226 vn_decode_uint32_t(dec, &val->maxMultiviewInstanceIndex);
6227 }
6228
6229 static inline void
vn_decode_VkPhysicalDeviceMultiviewProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewProperties * val)6230 vn_decode_VkPhysicalDeviceMultiviewProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewProperties *val)
6231 {
6232 VkStructureType stype;
6233 vn_decode_VkStructureType(dec, &stype);
6234 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
6235
6236 assert(val->sType == stype);
6237 vn_decode_VkPhysicalDeviceMultiviewProperties_pnext(dec, val->pNext);
6238 vn_decode_VkPhysicalDeviceMultiviewProperties_self(dec, val);
6239 }
6240
6241 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext_partial(const void * val)6242 vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext_partial(const void *val)
6243 {
6244 /* no known/supported struct */
6245 return vn_sizeof_simple_pointer(NULL);
6246 }
6247
6248 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial(const VkPhysicalDeviceMultiviewProperties * val)6249 vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial(const VkPhysicalDeviceMultiviewProperties *val)
6250 {
6251 size_t size = 0;
6252 /* skip val->{sType,pNext} */
6253 /* skip val->maxMultiviewViewCount */
6254 /* skip val->maxMultiviewInstanceIndex */
6255 return size;
6256 }
6257
6258 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_partial(const VkPhysicalDeviceMultiviewProperties * val)6259 vn_sizeof_VkPhysicalDeviceMultiviewProperties_partial(const VkPhysicalDeviceMultiviewProperties *val)
6260 {
6261 size_t size = 0;
6262
6263 size += vn_sizeof_VkStructureType(&val->sType);
6264 size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext_partial(val->pNext);
6265 size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial(val);
6266
6267 return size;
6268 }
6269
6270 static inline void
vn_encode_VkPhysicalDeviceMultiviewProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)6271 vn_encode_VkPhysicalDeviceMultiviewProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6272 {
6273 /* no known/supported struct */
6274 vn_encode_simple_pointer(enc, NULL);
6275 }
6276
6277 static inline void
vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewProperties * val)6278 vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewProperties *val)
6279 {
6280 /* skip val->{sType,pNext} */
6281 /* skip val->maxMultiviewViewCount */
6282 /* skip val->maxMultiviewInstanceIndex */
6283 }
6284
6285 static inline void
vn_encode_VkPhysicalDeviceMultiviewProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewProperties * val)6286 vn_encode_VkPhysicalDeviceMultiviewProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewProperties *val)
6287 {
6288 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
6289 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES });
6290 vn_encode_VkPhysicalDeviceMultiviewProperties_pnext_partial(enc, val->pNext);
6291 vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(enc, val);
6292 }
6293
6294 /* struct VkPhysicalDeviceSubgroupProperties chain */
6295
6296 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext(const void * val)6297 vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext(const void *val)
6298 {
6299 /* no known/supported struct */
6300 return vn_sizeof_simple_pointer(NULL);
6301 }
6302
6303 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_self(const VkPhysicalDeviceSubgroupProperties * val)6304 vn_sizeof_VkPhysicalDeviceSubgroupProperties_self(const VkPhysicalDeviceSubgroupProperties *val)
6305 {
6306 size_t size = 0;
6307 /* skip val->{sType,pNext} */
6308 size += vn_sizeof_uint32_t(&val->subgroupSize);
6309 size += vn_sizeof_VkFlags(&val->supportedStages);
6310 size += vn_sizeof_VkFlags(&val->supportedOperations);
6311 size += vn_sizeof_VkBool32(&val->quadOperationsInAllStages);
6312 return size;
6313 }
6314
6315 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties * val)6316 vn_sizeof_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties *val)
6317 {
6318 size_t size = 0;
6319
6320 size += vn_sizeof_VkStructureType(&val->sType);
6321 size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext(val->pNext);
6322 size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self(val);
6323
6324 return size;
6325 }
6326
6327 static inline void
vn_decode_VkPhysicalDeviceSubgroupProperties_pnext(struct vn_cs_decoder * dec,const void * val)6328 vn_decode_VkPhysicalDeviceSubgroupProperties_pnext(struct vn_cs_decoder *dec, const void *val)
6329 {
6330 /* no known/supported struct */
6331 if (vn_decode_simple_pointer(dec))
6332 assert(false);
6333 }
6334
6335 static inline void
vn_decode_VkPhysicalDeviceSubgroupProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSubgroupProperties * val)6336 vn_decode_VkPhysicalDeviceSubgroupProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupProperties *val)
6337 {
6338 /* skip val->{sType,pNext} */
6339 vn_decode_uint32_t(dec, &val->subgroupSize);
6340 vn_decode_VkFlags(dec, &val->supportedStages);
6341 vn_decode_VkFlags(dec, &val->supportedOperations);
6342 vn_decode_VkBool32(dec, &val->quadOperationsInAllStages);
6343 }
6344
6345 static inline void
vn_decode_VkPhysicalDeviceSubgroupProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceSubgroupProperties * val)6346 vn_decode_VkPhysicalDeviceSubgroupProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupProperties *val)
6347 {
6348 VkStructureType stype;
6349 vn_decode_VkStructureType(dec, &stype);
6350 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
6351
6352 assert(val->sType == stype);
6353 vn_decode_VkPhysicalDeviceSubgroupProperties_pnext(dec, val->pNext);
6354 vn_decode_VkPhysicalDeviceSubgroupProperties_self(dec, val);
6355 }
6356
6357 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext_partial(const void * val)6358 vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext_partial(const void *val)
6359 {
6360 /* no known/supported struct */
6361 return vn_sizeof_simple_pointer(NULL);
6362 }
6363
6364 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial(const VkPhysicalDeviceSubgroupProperties * val)6365 vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial(const VkPhysicalDeviceSubgroupProperties *val)
6366 {
6367 size_t size = 0;
6368 /* skip val->{sType,pNext} */
6369 /* skip val->subgroupSize */
6370 /* skip val->supportedStages */
6371 /* skip val->supportedOperations */
6372 /* skip val->quadOperationsInAllStages */
6373 return size;
6374 }
6375
6376 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_partial(const VkPhysicalDeviceSubgroupProperties * val)6377 vn_sizeof_VkPhysicalDeviceSubgroupProperties_partial(const VkPhysicalDeviceSubgroupProperties *val)
6378 {
6379 size_t size = 0;
6380
6381 size += vn_sizeof_VkStructureType(&val->sType);
6382 size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext_partial(val->pNext);
6383 size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial(val);
6384
6385 return size;
6386 }
6387
6388 static inline void
vn_encode_VkPhysicalDeviceSubgroupProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)6389 vn_encode_VkPhysicalDeviceSubgroupProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6390 {
6391 /* no known/supported struct */
6392 vn_encode_simple_pointer(enc, NULL);
6393 }
6394
6395 static inline void
vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupProperties * val)6396 vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupProperties *val)
6397 {
6398 /* skip val->{sType,pNext} */
6399 /* skip val->subgroupSize */
6400 /* skip val->supportedStages */
6401 /* skip val->supportedOperations */
6402 /* skip val->quadOperationsInAllStages */
6403 }
6404
6405 static inline void
vn_encode_VkPhysicalDeviceSubgroupProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupProperties * val)6406 vn_encode_VkPhysicalDeviceSubgroupProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupProperties *val)
6407 {
6408 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
6409 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES });
6410 vn_encode_VkPhysicalDeviceSubgroupProperties_pnext_partial(enc, val->pNext);
6411 vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(enc, val);
6412 }
6413
6414 /* struct VkPhysicalDevicePointClippingProperties chain */
6415
6416 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext(const void * val)6417 vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext(const void *val)
6418 {
6419 /* no known/supported struct */
6420 return vn_sizeof_simple_pointer(NULL);
6421 }
6422
6423 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_self(const VkPhysicalDevicePointClippingProperties * val)6424 vn_sizeof_VkPhysicalDevicePointClippingProperties_self(const VkPhysicalDevicePointClippingProperties *val)
6425 {
6426 size_t size = 0;
6427 /* skip val->{sType,pNext} */
6428 size += vn_sizeof_VkPointClippingBehavior(&val->pointClippingBehavior);
6429 return size;
6430 }
6431
6432 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties * val)6433 vn_sizeof_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties *val)
6434 {
6435 size_t size = 0;
6436
6437 size += vn_sizeof_VkStructureType(&val->sType);
6438 size += vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext(val->pNext);
6439 size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self(val);
6440
6441 return size;
6442 }
6443
6444 static inline void
vn_decode_VkPhysicalDevicePointClippingProperties_pnext(struct vn_cs_decoder * dec,const void * val)6445 vn_decode_VkPhysicalDevicePointClippingProperties_pnext(struct vn_cs_decoder *dec, const void *val)
6446 {
6447 /* no known/supported struct */
6448 if (vn_decode_simple_pointer(dec))
6449 assert(false);
6450 }
6451
6452 static inline void
vn_decode_VkPhysicalDevicePointClippingProperties_self(struct vn_cs_decoder * dec,VkPhysicalDevicePointClippingProperties * val)6453 vn_decode_VkPhysicalDevicePointClippingProperties_self(struct vn_cs_decoder *dec, VkPhysicalDevicePointClippingProperties *val)
6454 {
6455 /* skip val->{sType,pNext} */
6456 vn_decode_VkPointClippingBehavior(dec, &val->pointClippingBehavior);
6457 }
6458
6459 static inline void
vn_decode_VkPhysicalDevicePointClippingProperties(struct vn_cs_decoder * dec,VkPhysicalDevicePointClippingProperties * val)6460 vn_decode_VkPhysicalDevicePointClippingProperties(struct vn_cs_decoder *dec, VkPhysicalDevicePointClippingProperties *val)
6461 {
6462 VkStructureType stype;
6463 vn_decode_VkStructureType(dec, &stype);
6464 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
6465
6466 assert(val->sType == stype);
6467 vn_decode_VkPhysicalDevicePointClippingProperties_pnext(dec, val->pNext);
6468 vn_decode_VkPhysicalDevicePointClippingProperties_self(dec, val);
6469 }
6470
6471 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext_partial(const void * val)6472 vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext_partial(const void *val)
6473 {
6474 /* no known/supported struct */
6475 return vn_sizeof_simple_pointer(NULL);
6476 }
6477
6478 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial(const VkPhysicalDevicePointClippingProperties * val)6479 vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial(const VkPhysicalDevicePointClippingProperties *val)
6480 {
6481 size_t size = 0;
6482 /* skip val->{sType,pNext} */
6483 /* skip val->pointClippingBehavior */
6484 return size;
6485 }
6486
6487 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_partial(const VkPhysicalDevicePointClippingProperties * val)6488 vn_sizeof_VkPhysicalDevicePointClippingProperties_partial(const VkPhysicalDevicePointClippingProperties *val)
6489 {
6490 size_t size = 0;
6491
6492 size += vn_sizeof_VkStructureType(&val->sType);
6493 size += vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext_partial(val->pNext);
6494 size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial(val);
6495
6496 return size;
6497 }
6498
6499 static inline void
vn_encode_VkPhysicalDevicePointClippingProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)6500 vn_encode_VkPhysicalDevicePointClippingProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6501 {
6502 /* no known/supported struct */
6503 vn_encode_simple_pointer(enc, NULL);
6504 }
6505
6506 static inline void
vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePointClippingProperties * val)6507 vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePointClippingProperties *val)
6508 {
6509 /* skip val->{sType,pNext} */
6510 /* skip val->pointClippingBehavior */
6511 }
6512
6513 static inline void
vn_encode_VkPhysicalDevicePointClippingProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePointClippingProperties * val)6514 vn_encode_VkPhysicalDevicePointClippingProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePointClippingProperties *val)
6515 {
6516 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
6517 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES });
6518 vn_encode_VkPhysicalDevicePointClippingProperties_pnext_partial(enc, val->pNext);
6519 vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(enc, val);
6520 }
6521
6522 /* struct VkPhysicalDeviceProtectedMemoryProperties chain */
6523
6524 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext(const void * val)6525 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext(const void *val)
6526 {
6527 /* no known/supported struct */
6528 return vn_sizeof_simple_pointer(NULL);
6529 }
6530
6531 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self(const VkPhysicalDeviceProtectedMemoryProperties * val)6532 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self(const VkPhysicalDeviceProtectedMemoryProperties *val)
6533 {
6534 size_t size = 0;
6535 /* skip val->{sType,pNext} */
6536 size += vn_sizeof_VkBool32(&val->protectedNoFault);
6537 return size;
6538 }
6539
6540 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties * val)6541 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties *val)
6542 {
6543 size_t size = 0;
6544
6545 size += vn_sizeof_VkStructureType(&val->sType);
6546 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext(val->pNext);
6547 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self(val);
6548
6549 return size;
6550 }
6551
6552 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext(struct vn_cs_decoder * dec,const void * val)6553 vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext(struct vn_cs_decoder *dec, const void *val)
6554 {
6555 /* no known/supported struct */
6556 if (vn_decode_simple_pointer(dec))
6557 assert(false);
6558 }
6559
6560 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryProperties * val)6561 vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryProperties *val)
6562 {
6563 /* skip val->{sType,pNext} */
6564 vn_decode_VkBool32(dec, &val->protectedNoFault);
6565 }
6566
6567 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryProperties * val)6568 vn_decode_VkPhysicalDeviceProtectedMemoryProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryProperties *val)
6569 {
6570 VkStructureType stype;
6571 vn_decode_VkStructureType(dec, &stype);
6572 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
6573
6574 assert(val->sType == stype);
6575 vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext(dec, val->pNext);
6576 vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(dec, val);
6577 }
6578
6579 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(const void * val)6580 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(const void *val)
6581 {
6582 /* no known/supported struct */
6583 return vn_sizeof_simple_pointer(NULL);
6584 }
6585
6586 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial(const VkPhysicalDeviceProtectedMemoryProperties * val)6587 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial(const VkPhysicalDeviceProtectedMemoryProperties *val)
6588 {
6589 size_t size = 0;
6590 /* skip val->{sType,pNext} */
6591 /* skip val->protectedNoFault */
6592 return size;
6593 }
6594
6595 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_partial(const VkPhysicalDeviceProtectedMemoryProperties * val)6596 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_partial(const VkPhysicalDeviceProtectedMemoryProperties *val)
6597 {
6598 size_t size = 0;
6599
6600 size += vn_sizeof_VkStructureType(&val->sType);
6601 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(val->pNext);
6602 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial(val);
6603
6604 return size;
6605 }
6606
6607 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)6608 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6609 {
6610 /* no known/supported struct */
6611 vn_encode_simple_pointer(enc, NULL);
6612 }
6613
6614 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryProperties * val)6615 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryProperties *val)
6616 {
6617 /* skip val->{sType,pNext} */
6618 /* skip val->protectedNoFault */
6619 }
6620
6621 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryProperties * val)6622 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryProperties *val)
6623 {
6624 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
6625 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES });
6626 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(enc, val->pNext);
6627 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(enc, val);
6628 }
6629
6630 /* struct VkPhysicalDeviceSamplerFilterMinmaxProperties chain */
6631
6632 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(const void * val)6633 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(const void *val)
6634 {
6635 /* no known/supported struct */
6636 return vn_sizeof_simple_pointer(NULL);
6637 }
6638
6639 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)6640 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
6641 {
6642 size_t size = 0;
6643 /* skip val->{sType,pNext} */
6644 size += vn_sizeof_VkBool32(&val->filterMinmaxSingleComponentFormats);
6645 size += vn_sizeof_VkBool32(&val->filterMinmaxImageComponentMapping);
6646 return size;
6647 }
6648
6649 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)6650 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
6651 {
6652 size_t size = 0;
6653
6654 size += vn_sizeof_VkStructureType(&val->sType);
6655 size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(val->pNext);
6656 size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(val);
6657
6658 return size;
6659 }
6660
6661 static inline void
vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(struct vn_cs_decoder * dec,const void * val)6662 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(struct vn_cs_decoder *dec, const void *val)
6663 {
6664 /* no known/supported struct */
6665 if (vn_decode_simple_pointer(dec))
6666 assert(false);
6667 }
6668
6669 static inline void
vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerFilterMinmaxProperties * val)6670 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
6671 {
6672 /* skip val->{sType,pNext} */
6673 vn_decode_VkBool32(dec, &val->filterMinmaxSingleComponentFormats);
6674 vn_decode_VkBool32(dec, &val->filterMinmaxImageComponentMapping);
6675 }
6676
6677 static inline void
vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerFilterMinmaxProperties * val)6678 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
6679 {
6680 VkStructureType stype;
6681 vn_decode_VkStructureType(dec, &stype);
6682 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
6683
6684 assert(val->sType == stype);
6685 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(dec, val->pNext);
6686 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(dec, val);
6687 }
6688
6689 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(const void * val)6690 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(const void *val)
6691 {
6692 /* no known/supported struct */
6693 return vn_sizeof_simple_pointer(NULL);
6694 }
6695
6696 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)6697 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
6698 {
6699 size_t size = 0;
6700 /* skip val->{sType,pNext} */
6701 /* skip val->filterMinmaxSingleComponentFormats */
6702 /* skip val->filterMinmaxImageComponentMapping */
6703 return size;
6704 }
6705
6706 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)6707 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
6708 {
6709 size_t size = 0;
6710
6711 size += vn_sizeof_VkStructureType(&val->sType);
6712 size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(val->pNext);
6713 size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(val);
6714
6715 return size;
6716 }
6717
6718 static inline void
vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)6719 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6720 {
6721 /* no known/supported struct */
6722 vn_encode_simple_pointer(enc, NULL);
6723 }
6724
6725 static inline void
vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)6726 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
6727 {
6728 /* skip val->{sType,pNext} */
6729 /* skip val->filterMinmaxSingleComponentFormats */
6730 /* skip val->filterMinmaxImageComponentMapping */
6731 }
6732
6733 static inline void
vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)6734 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
6735 {
6736 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
6737 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES });
6738 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(enc, val->pNext);
6739 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(enc, val);
6740 }
6741
6742 /* struct VkPhysicalDeviceMaintenance3Properties chain */
6743
6744 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext(const void * val)6745 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext(const void *val)
6746 {
6747 /* no known/supported struct */
6748 return vn_sizeof_simple_pointer(NULL);
6749 }
6750
6751 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self(const VkPhysicalDeviceMaintenance3Properties * val)6752 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self(const VkPhysicalDeviceMaintenance3Properties *val)
6753 {
6754 size_t size = 0;
6755 /* skip val->{sType,pNext} */
6756 size += vn_sizeof_uint32_t(&val->maxPerSetDescriptors);
6757 size += vn_sizeof_VkDeviceSize(&val->maxMemoryAllocationSize);
6758 return size;
6759 }
6760
6761 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties * val)6762 vn_sizeof_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties *val)
6763 {
6764 size_t size = 0;
6765
6766 size += vn_sizeof_VkStructureType(&val->sType);
6767 size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext(val->pNext);
6768 size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self(val);
6769
6770 return size;
6771 }
6772
6773 static inline void
vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext(struct vn_cs_decoder * dec,const void * val)6774 vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext(struct vn_cs_decoder *dec, const void *val)
6775 {
6776 /* no known/supported struct */
6777 if (vn_decode_simple_pointer(dec))
6778 assert(false);
6779 }
6780
6781 static inline void
vn_decode_VkPhysicalDeviceMaintenance3Properties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance3Properties * val)6782 vn_decode_VkPhysicalDeviceMaintenance3Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance3Properties *val)
6783 {
6784 /* skip val->{sType,pNext} */
6785 vn_decode_uint32_t(dec, &val->maxPerSetDescriptors);
6786 vn_decode_VkDeviceSize(dec, &val->maxMemoryAllocationSize);
6787 }
6788
6789 static inline void
vn_decode_VkPhysicalDeviceMaintenance3Properties(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance3Properties * val)6790 vn_decode_VkPhysicalDeviceMaintenance3Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance3Properties *val)
6791 {
6792 VkStructureType stype;
6793 vn_decode_VkStructureType(dec, &stype);
6794 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
6795
6796 assert(val->sType == stype);
6797 vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext(dec, val->pNext);
6798 vn_decode_VkPhysicalDeviceMaintenance3Properties_self(dec, val);
6799 }
6800
6801 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext_partial(const void * val)6802 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext_partial(const void *val)
6803 {
6804 /* no known/supported struct */
6805 return vn_sizeof_simple_pointer(NULL);
6806 }
6807
6808 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial(const VkPhysicalDeviceMaintenance3Properties * val)6809 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial(const VkPhysicalDeviceMaintenance3Properties *val)
6810 {
6811 size_t size = 0;
6812 /* skip val->{sType,pNext} */
6813 /* skip val->maxPerSetDescriptors */
6814 /* skip val->maxMemoryAllocationSize */
6815 return size;
6816 }
6817
6818 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_partial(const VkPhysicalDeviceMaintenance3Properties * val)6819 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_partial(const VkPhysicalDeviceMaintenance3Properties *val)
6820 {
6821 size_t size = 0;
6822
6823 size += vn_sizeof_VkStructureType(&val->sType);
6824 size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext_partial(val->pNext);
6825 size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial(val);
6826
6827 return size;
6828 }
6829
6830 static inline void
vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext_partial(struct vn_cs_encoder * enc,const void * val)6831 vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6832 {
6833 /* no known/supported struct */
6834 vn_encode_simple_pointer(enc, NULL);
6835 }
6836
6837 static inline void
vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance3Properties * val)6838 vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance3Properties *val)
6839 {
6840 /* skip val->{sType,pNext} */
6841 /* skip val->maxPerSetDescriptors */
6842 /* skip val->maxMemoryAllocationSize */
6843 }
6844
6845 static inline void
vn_encode_VkPhysicalDeviceMaintenance3Properties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance3Properties * val)6846 vn_encode_VkPhysicalDeviceMaintenance3Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance3Properties *val)
6847 {
6848 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
6849 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES });
6850 vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext_partial(enc, val->pNext);
6851 vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(enc, val);
6852 }
6853
6854 /* struct VkPhysicalDeviceFloatControlsProperties chain */
6855
6856 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext(const void * val)6857 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext(const void *val)
6858 {
6859 /* no known/supported struct */
6860 return vn_sizeof_simple_pointer(NULL);
6861 }
6862
6863 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self(const VkPhysicalDeviceFloatControlsProperties * val)6864 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self(const VkPhysicalDeviceFloatControlsProperties *val)
6865 {
6866 size_t size = 0;
6867 /* skip val->{sType,pNext} */
6868 size += vn_sizeof_VkShaderFloatControlsIndependence(&val->denormBehaviorIndependence);
6869 size += vn_sizeof_VkShaderFloatControlsIndependence(&val->roundingModeIndependence);
6870 size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat16);
6871 size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat32);
6872 size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat64);
6873 size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat16);
6874 size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat32);
6875 size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat64);
6876 size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat16);
6877 size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat32);
6878 size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat64);
6879 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat16);
6880 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat32);
6881 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat64);
6882 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat16);
6883 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat32);
6884 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat64);
6885 return size;
6886 }
6887
6888 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties * val)6889 vn_sizeof_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties *val)
6890 {
6891 size_t size = 0;
6892
6893 size += vn_sizeof_VkStructureType(&val->sType);
6894 size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext(val->pNext);
6895 size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self(val);
6896
6897 return size;
6898 }
6899
6900 static inline void
vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext(struct vn_cs_decoder * dec,const void * val)6901 vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext(struct vn_cs_decoder *dec, const void *val)
6902 {
6903 /* no known/supported struct */
6904 if (vn_decode_simple_pointer(dec))
6905 assert(false);
6906 }
6907
6908 static inline void
vn_decode_VkPhysicalDeviceFloatControlsProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceFloatControlsProperties * val)6909 vn_decode_VkPhysicalDeviceFloatControlsProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceFloatControlsProperties *val)
6910 {
6911 /* skip val->{sType,pNext} */
6912 vn_decode_VkShaderFloatControlsIndependence(dec, &val->denormBehaviorIndependence);
6913 vn_decode_VkShaderFloatControlsIndependence(dec, &val->roundingModeIndependence);
6914 vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat16);
6915 vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat32);
6916 vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat64);
6917 vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat16);
6918 vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat32);
6919 vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat64);
6920 vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat16);
6921 vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat32);
6922 vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat64);
6923 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat16);
6924 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat32);
6925 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat64);
6926 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat16);
6927 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat32);
6928 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat64);
6929 }
6930
6931 static inline void
vn_decode_VkPhysicalDeviceFloatControlsProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceFloatControlsProperties * val)6932 vn_decode_VkPhysicalDeviceFloatControlsProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceFloatControlsProperties *val)
6933 {
6934 VkStructureType stype;
6935 vn_decode_VkStructureType(dec, &stype);
6936 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
6937
6938 assert(val->sType == stype);
6939 vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext(dec, val->pNext);
6940 vn_decode_VkPhysicalDeviceFloatControlsProperties_self(dec, val);
6941 }
6942
6943 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext_partial(const void * val)6944 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext_partial(const void *val)
6945 {
6946 /* no known/supported struct */
6947 return vn_sizeof_simple_pointer(NULL);
6948 }
6949
6950 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial(const VkPhysicalDeviceFloatControlsProperties * val)6951 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial(const VkPhysicalDeviceFloatControlsProperties *val)
6952 {
6953 size_t size = 0;
6954 /* skip val->{sType,pNext} */
6955 /* skip val->denormBehaviorIndependence */
6956 /* skip val->roundingModeIndependence */
6957 /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
6958 /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
6959 /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
6960 /* skip val->shaderDenormPreserveFloat16 */
6961 /* skip val->shaderDenormPreserveFloat32 */
6962 /* skip val->shaderDenormPreserveFloat64 */
6963 /* skip val->shaderDenormFlushToZeroFloat16 */
6964 /* skip val->shaderDenormFlushToZeroFloat32 */
6965 /* skip val->shaderDenormFlushToZeroFloat64 */
6966 /* skip val->shaderRoundingModeRTEFloat16 */
6967 /* skip val->shaderRoundingModeRTEFloat32 */
6968 /* skip val->shaderRoundingModeRTEFloat64 */
6969 /* skip val->shaderRoundingModeRTZFloat16 */
6970 /* skip val->shaderRoundingModeRTZFloat32 */
6971 /* skip val->shaderRoundingModeRTZFloat64 */
6972 return size;
6973 }
6974
6975 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_partial(const VkPhysicalDeviceFloatControlsProperties * val)6976 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_partial(const VkPhysicalDeviceFloatControlsProperties *val)
6977 {
6978 size_t size = 0;
6979
6980 size += vn_sizeof_VkStructureType(&val->sType);
6981 size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext_partial(val->pNext);
6982 size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial(val);
6983
6984 return size;
6985 }
6986
6987 static inline void
vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)6988 vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6989 {
6990 /* no known/supported struct */
6991 vn_encode_simple_pointer(enc, NULL);
6992 }
6993
6994 static inline void
vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFloatControlsProperties * val)6995 vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFloatControlsProperties *val)
6996 {
6997 /* skip val->{sType,pNext} */
6998 /* skip val->denormBehaviorIndependence */
6999 /* skip val->roundingModeIndependence */
7000 /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
7001 /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
7002 /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
7003 /* skip val->shaderDenormPreserveFloat16 */
7004 /* skip val->shaderDenormPreserveFloat32 */
7005 /* skip val->shaderDenormPreserveFloat64 */
7006 /* skip val->shaderDenormFlushToZeroFloat16 */
7007 /* skip val->shaderDenormFlushToZeroFloat32 */
7008 /* skip val->shaderDenormFlushToZeroFloat64 */
7009 /* skip val->shaderRoundingModeRTEFloat16 */
7010 /* skip val->shaderRoundingModeRTEFloat32 */
7011 /* skip val->shaderRoundingModeRTEFloat64 */
7012 /* skip val->shaderRoundingModeRTZFloat16 */
7013 /* skip val->shaderRoundingModeRTZFloat32 */
7014 /* skip val->shaderRoundingModeRTZFloat64 */
7015 }
7016
7017 static inline void
vn_encode_VkPhysicalDeviceFloatControlsProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFloatControlsProperties * val)7018 vn_encode_VkPhysicalDeviceFloatControlsProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFloatControlsProperties *val)
7019 {
7020 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
7021 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES });
7022 vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext_partial(enc, val->pNext);
7023 vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(enc, val);
7024 }
7025
7026 /* struct VkPhysicalDeviceDescriptorIndexingProperties chain */
7027
7028 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext(const void * val)7029 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext(const void *val)
7030 {
7031 /* no known/supported struct */
7032 return vn_sizeof_simple_pointer(NULL);
7033 }
7034
7035 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self(const VkPhysicalDeviceDescriptorIndexingProperties * val)7036 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self(const VkPhysicalDeviceDescriptorIndexingProperties *val)
7037 {
7038 size_t size = 0;
7039 /* skip val->{sType,pNext} */
7040 size += vn_sizeof_uint32_t(&val->maxUpdateAfterBindDescriptorsInAllPools);
7041 size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexingNative);
7042 size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexingNative);
7043 size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexingNative);
7044 size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexingNative);
7045 size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexingNative);
7046 size += vn_sizeof_VkBool32(&val->robustBufferAccessUpdateAfterBind);
7047 size += vn_sizeof_VkBool32(&val->quadDivergentImplicitLod);
7048 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSamplers);
7049 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
7050 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
7051 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSampledImages);
7052 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageImages);
7053 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
7054 size += vn_sizeof_uint32_t(&val->maxPerStageUpdateAfterBindResources);
7055 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSamplers);
7056 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffers);
7057 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
7058 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffers);
7059 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
7060 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSampledImages);
7061 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageImages);
7062 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInputAttachments);
7063 return size;
7064 }
7065
7066 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties * val)7067 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties *val)
7068 {
7069 size_t size = 0;
7070
7071 size += vn_sizeof_VkStructureType(&val->sType);
7072 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext(val->pNext);
7073 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self(val);
7074
7075 return size;
7076 }
7077
7078 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(struct vn_cs_decoder * dec,const void * val)7079 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(struct vn_cs_decoder *dec, const void *val)
7080 {
7081 /* no known/supported struct */
7082 if (vn_decode_simple_pointer(dec))
7083 assert(false);
7084 }
7085
7086 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingProperties * val)7087 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingProperties *val)
7088 {
7089 /* skip val->{sType,pNext} */
7090 vn_decode_uint32_t(dec, &val->maxUpdateAfterBindDescriptorsInAllPools);
7091 vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexingNative);
7092 vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexingNative);
7093 vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexingNative);
7094 vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexingNative);
7095 vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexingNative);
7096 vn_decode_VkBool32(dec, &val->robustBufferAccessUpdateAfterBind);
7097 vn_decode_VkBool32(dec, &val->quadDivergentImplicitLod);
7098 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSamplers);
7099 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
7100 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
7101 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSampledImages);
7102 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageImages);
7103 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
7104 vn_decode_uint32_t(dec, &val->maxPerStageUpdateAfterBindResources);
7105 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSamplers);
7106 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffers);
7107 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
7108 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffers);
7109 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
7110 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSampledImages);
7111 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageImages);
7112 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInputAttachments);
7113 }
7114
7115 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingProperties * val)7116 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingProperties *val)
7117 {
7118 VkStructureType stype;
7119 vn_decode_VkStructureType(dec, &stype);
7120 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
7121
7122 assert(val->sType == stype);
7123 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(dec, val->pNext);
7124 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(dec, val);
7125 }
7126
7127 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(const void * val)7128 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(const void *val)
7129 {
7130 /* no known/supported struct */
7131 return vn_sizeof_simple_pointer(NULL);
7132 }
7133
7134 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(const VkPhysicalDeviceDescriptorIndexingProperties * val)7135 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(const VkPhysicalDeviceDescriptorIndexingProperties *val)
7136 {
7137 size_t size = 0;
7138 /* skip val->{sType,pNext} */
7139 /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
7140 /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
7141 /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
7142 /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
7143 /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
7144 /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
7145 /* skip val->robustBufferAccessUpdateAfterBind */
7146 /* skip val->quadDivergentImplicitLod */
7147 /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
7148 /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
7149 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
7150 /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
7151 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
7152 /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
7153 /* skip val->maxPerStageUpdateAfterBindResources */
7154 /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
7155 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
7156 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
7157 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
7158 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
7159 /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
7160 /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
7161 /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
7162 return size;
7163 }
7164
7165 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_partial(const VkPhysicalDeviceDescriptorIndexingProperties * val)7166 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_partial(const VkPhysicalDeviceDescriptorIndexingProperties *val)
7167 {
7168 size_t size = 0;
7169
7170 size += vn_sizeof_VkStructureType(&val->sType);
7171 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(val->pNext);
7172 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(val);
7173
7174 return size;
7175 }
7176
7177 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)7178 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7179 {
7180 /* no known/supported struct */
7181 vn_encode_simple_pointer(enc, NULL);
7182 }
7183
7184 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingProperties * val)7185 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingProperties *val)
7186 {
7187 /* skip val->{sType,pNext} */
7188 /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
7189 /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
7190 /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
7191 /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
7192 /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
7193 /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
7194 /* skip val->robustBufferAccessUpdateAfterBind */
7195 /* skip val->quadDivergentImplicitLod */
7196 /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
7197 /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
7198 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
7199 /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
7200 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
7201 /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
7202 /* skip val->maxPerStageUpdateAfterBindResources */
7203 /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
7204 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
7205 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
7206 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
7207 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
7208 /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
7209 /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
7210 /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
7211 }
7212
7213 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingProperties * val)7214 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingProperties *val)
7215 {
7216 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
7217 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES });
7218 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(enc, val->pNext);
7219 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(enc, val);
7220 }
7221
7222 /* struct VkPhysicalDeviceTimelineSemaphoreProperties chain */
7223
7224 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(const void * val)7225 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(const void *val)
7226 {
7227 /* no known/supported struct */
7228 return vn_sizeof_simple_pointer(NULL);
7229 }
7230
7231 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self(const VkPhysicalDeviceTimelineSemaphoreProperties * val)7232 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
7233 {
7234 size_t size = 0;
7235 /* skip val->{sType,pNext} */
7236 size += vn_sizeof_uint64_t(&val->maxTimelineSemaphoreValueDifference);
7237 return size;
7238 }
7239
7240 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties * val)7241 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
7242 {
7243 size_t size = 0;
7244
7245 size += vn_sizeof_VkStructureType(&val->sType);
7246 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(val->pNext);
7247 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self(val);
7248
7249 return size;
7250 }
7251
7252 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(struct vn_cs_decoder * dec,const void * val)7253 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(struct vn_cs_decoder *dec, const void *val)
7254 {
7255 /* no known/supported struct */
7256 if (vn_decode_simple_pointer(dec))
7257 assert(false);
7258 }
7259
7260 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreProperties * val)7261 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreProperties *val)
7262 {
7263 /* skip val->{sType,pNext} */
7264 vn_decode_uint64_t(dec, &val->maxTimelineSemaphoreValueDifference);
7265 }
7266
7267 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreProperties * val)7268 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreProperties *val)
7269 {
7270 VkStructureType stype;
7271 vn_decode_VkStructureType(dec, &stype);
7272 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
7273
7274 assert(val->sType == stype);
7275 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(dec, val->pNext);
7276 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(dec, val);
7277 }
7278
7279 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(const void * val)7280 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(const void *val)
7281 {
7282 /* no known/supported struct */
7283 return vn_sizeof_simple_pointer(NULL);
7284 }
7285
7286 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(const VkPhysicalDeviceTimelineSemaphoreProperties * val)7287 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
7288 {
7289 size_t size = 0;
7290 /* skip val->{sType,pNext} */
7291 /* skip val->maxTimelineSemaphoreValueDifference */
7292 return size;
7293 }
7294
7295 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_partial(const VkPhysicalDeviceTimelineSemaphoreProperties * val)7296 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_partial(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
7297 {
7298 size_t size = 0;
7299
7300 size += vn_sizeof_VkStructureType(&val->sType);
7301 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(val->pNext);
7302 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(val);
7303
7304 return size;
7305 }
7306
7307 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)7308 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7309 {
7310 /* no known/supported struct */
7311 vn_encode_simple_pointer(enc, NULL);
7312 }
7313
7314 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreProperties * val)7315 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreProperties *val)
7316 {
7317 /* skip val->{sType,pNext} */
7318 /* skip val->maxTimelineSemaphoreValueDifference */
7319 }
7320
7321 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreProperties * val)7322 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreProperties *val)
7323 {
7324 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
7325 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES });
7326 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(enc, val->pNext);
7327 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(enc, val);
7328 }
7329
7330 /* struct VkPhysicalDeviceDepthStencilResolveProperties chain */
7331
7332 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext(const void * val)7333 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext(const void *val)
7334 {
7335 /* no known/supported struct */
7336 return vn_sizeof_simple_pointer(NULL);
7337 }
7338
7339 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self(const VkPhysicalDeviceDepthStencilResolveProperties * val)7340 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self(const VkPhysicalDeviceDepthStencilResolveProperties *val)
7341 {
7342 size_t size = 0;
7343 /* skip val->{sType,pNext} */
7344 size += vn_sizeof_VkFlags(&val->supportedDepthResolveModes);
7345 size += vn_sizeof_VkFlags(&val->supportedStencilResolveModes);
7346 size += vn_sizeof_VkBool32(&val->independentResolveNone);
7347 size += vn_sizeof_VkBool32(&val->independentResolve);
7348 return size;
7349 }
7350
7351 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties * val)7352 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties *val)
7353 {
7354 size_t size = 0;
7355
7356 size += vn_sizeof_VkStructureType(&val->sType);
7357 size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext(val->pNext);
7358 size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self(val);
7359
7360 return size;
7361 }
7362
7363 static inline void
vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(struct vn_cs_decoder * dec,const void * val)7364 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(struct vn_cs_decoder *dec, const void *val)
7365 {
7366 /* no known/supported struct */
7367 if (vn_decode_simple_pointer(dec))
7368 assert(false);
7369 }
7370
7371 static inline void
vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDepthStencilResolveProperties * val)7372 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthStencilResolveProperties *val)
7373 {
7374 /* skip val->{sType,pNext} */
7375 vn_decode_VkFlags(dec, &val->supportedDepthResolveModes);
7376 vn_decode_VkFlags(dec, &val->supportedStencilResolveModes);
7377 vn_decode_VkBool32(dec, &val->independentResolveNone);
7378 vn_decode_VkBool32(dec, &val->independentResolve);
7379 }
7380
7381 static inline void
vn_decode_VkPhysicalDeviceDepthStencilResolveProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceDepthStencilResolveProperties * val)7382 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthStencilResolveProperties *val)
7383 {
7384 VkStructureType stype;
7385 vn_decode_VkStructureType(dec, &stype);
7386 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
7387
7388 assert(val->sType == stype);
7389 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(dec, val->pNext);
7390 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(dec, val);
7391 }
7392
7393 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(const void * val)7394 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(const void *val)
7395 {
7396 /* no known/supported struct */
7397 return vn_sizeof_simple_pointer(NULL);
7398 }
7399
7400 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(const VkPhysicalDeviceDepthStencilResolveProperties * val)7401 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(const VkPhysicalDeviceDepthStencilResolveProperties *val)
7402 {
7403 size_t size = 0;
7404 /* skip val->{sType,pNext} */
7405 /* skip val->supportedDepthResolveModes */
7406 /* skip val->supportedStencilResolveModes */
7407 /* skip val->independentResolveNone */
7408 /* skip val->independentResolve */
7409 return size;
7410 }
7411
7412 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_partial(const VkPhysicalDeviceDepthStencilResolveProperties * val)7413 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_partial(const VkPhysicalDeviceDepthStencilResolveProperties *val)
7414 {
7415 size_t size = 0;
7416
7417 size += vn_sizeof_VkStructureType(&val->sType);
7418 size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(val->pNext);
7419 size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(val);
7420
7421 return size;
7422 }
7423
7424 static inline void
vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)7425 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7426 {
7427 /* no known/supported struct */
7428 vn_encode_simple_pointer(enc, NULL);
7429 }
7430
7431 static inline void
vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthStencilResolveProperties * val)7432 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthStencilResolveProperties *val)
7433 {
7434 /* skip val->{sType,pNext} */
7435 /* skip val->supportedDepthResolveModes */
7436 /* skip val->supportedStencilResolveModes */
7437 /* skip val->independentResolveNone */
7438 /* skip val->independentResolve */
7439 }
7440
7441 static inline void
vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthStencilResolveProperties * val)7442 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthStencilResolveProperties *val)
7443 {
7444 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
7445 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES });
7446 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(enc, val->pNext);
7447 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(enc, val);
7448 }
7449
7450 /* struct VkPhysicalDeviceTransformFeedbackPropertiesEXT chain */
7451
7452 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(const void * val)7453 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(const void *val)
7454 {
7455 /* no known/supported struct */
7456 return vn_sizeof_simple_pointer(NULL);
7457 }
7458
7459 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)7460 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
7461 {
7462 size_t size = 0;
7463 /* skip val->{sType,pNext} */
7464 size += vn_sizeof_uint32_t(&val->maxTransformFeedbackStreams);
7465 size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBuffers);
7466 size += vn_sizeof_VkDeviceSize(&val->maxTransformFeedbackBufferSize);
7467 size += vn_sizeof_uint32_t(&val->maxTransformFeedbackStreamDataSize);
7468 size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBufferDataSize);
7469 size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBufferDataStride);
7470 size += vn_sizeof_VkBool32(&val->transformFeedbackQueries);
7471 size += vn_sizeof_VkBool32(&val->transformFeedbackStreamsLinesTriangles);
7472 size += vn_sizeof_VkBool32(&val->transformFeedbackRasterizationStreamSelect);
7473 size += vn_sizeof_VkBool32(&val->transformFeedbackDraw);
7474 return size;
7475 }
7476
7477 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)7478 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
7479 {
7480 size_t size = 0;
7481
7482 size += vn_sizeof_VkStructureType(&val->sType);
7483 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(val->pNext);
7484 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(val);
7485
7486 return size;
7487 }
7488
7489 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)7490 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
7491 {
7492 /* no known/supported struct */
7493 if (vn_decode_simple_pointer(dec))
7494 assert(false);
7495 }
7496
7497 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)7498 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
7499 {
7500 /* skip val->{sType,pNext} */
7501 vn_decode_uint32_t(dec, &val->maxTransformFeedbackStreams);
7502 vn_decode_uint32_t(dec, &val->maxTransformFeedbackBuffers);
7503 vn_decode_VkDeviceSize(dec, &val->maxTransformFeedbackBufferSize);
7504 vn_decode_uint32_t(dec, &val->maxTransformFeedbackStreamDataSize);
7505 vn_decode_uint32_t(dec, &val->maxTransformFeedbackBufferDataSize);
7506 vn_decode_uint32_t(dec, &val->maxTransformFeedbackBufferDataStride);
7507 vn_decode_VkBool32(dec, &val->transformFeedbackQueries);
7508 vn_decode_VkBool32(dec, &val->transformFeedbackStreamsLinesTriangles);
7509 vn_decode_VkBool32(dec, &val->transformFeedbackRasterizationStreamSelect);
7510 vn_decode_VkBool32(dec, &val->transformFeedbackDraw);
7511 }
7512
7513 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)7514 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
7515 {
7516 VkStructureType stype;
7517 vn_decode_VkStructureType(dec, &stype);
7518 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
7519
7520 assert(val->sType == stype);
7521 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(dec, val->pNext);
7522 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(dec, val);
7523 }
7524
7525 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(const void * val)7526 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(const void *val)
7527 {
7528 /* no known/supported struct */
7529 return vn_sizeof_simple_pointer(NULL);
7530 }
7531
7532 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)7533 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
7534 {
7535 size_t size = 0;
7536 /* skip val->{sType,pNext} */
7537 /* skip val->maxTransformFeedbackStreams */
7538 /* skip val->maxTransformFeedbackBuffers */
7539 /* skip val->maxTransformFeedbackBufferSize */
7540 /* skip val->maxTransformFeedbackStreamDataSize */
7541 /* skip val->maxTransformFeedbackBufferDataSize */
7542 /* skip val->maxTransformFeedbackBufferDataStride */
7543 /* skip val->transformFeedbackQueries */
7544 /* skip val->transformFeedbackStreamsLinesTriangles */
7545 /* skip val->transformFeedbackRasterizationStreamSelect */
7546 /* skip val->transformFeedbackDraw */
7547 return size;
7548 }
7549
7550 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)7551 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
7552 {
7553 size_t size = 0;
7554
7555 size += vn_sizeof_VkStructureType(&val->sType);
7556 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(val->pNext);
7557 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(val);
7558
7559 return size;
7560 }
7561
7562 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)7563 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7564 {
7565 /* no known/supported struct */
7566 vn_encode_simple_pointer(enc, NULL);
7567 }
7568
7569 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)7570 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
7571 {
7572 /* skip val->{sType,pNext} */
7573 /* skip val->maxTransformFeedbackStreams */
7574 /* skip val->maxTransformFeedbackBuffers */
7575 /* skip val->maxTransformFeedbackBufferSize */
7576 /* skip val->maxTransformFeedbackStreamDataSize */
7577 /* skip val->maxTransformFeedbackBufferDataSize */
7578 /* skip val->maxTransformFeedbackBufferDataStride */
7579 /* skip val->transformFeedbackQueries */
7580 /* skip val->transformFeedbackStreamsLinesTriangles */
7581 /* skip val->transformFeedbackRasterizationStreamSelect */
7582 /* skip val->transformFeedbackDraw */
7583 }
7584
7585 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)7586 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
7587 {
7588 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
7589 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT });
7590 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(enc, val->pNext);
7591 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(enc, val);
7592 }
7593
7594 /* struct VkPhysicalDeviceVulkan11Properties chain */
7595
7596 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext(const void * val)7597 vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext(const void *val)
7598 {
7599 /* no known/supported struct */
7600 return vn_sizeof_simple_pointer(NULL);
7601 }
7602
7603 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_self(const VkPhysicalDeviceVulkan11Properties * val)7604 vn_sizeof_VkPhysicalDeviceVulkan11Properties_self(const VkPhysicalDeviceVulkan11Properties *val)
7605 {
7606 size_t size = 0;
7607 /* skip val->{sType,pNext} */
7608 size += vn_sizeof_array_size(VK_UUID_SIZE);
7609 size += vn_sizeof_uint8_t_array(val->deviceUUID, VK_UUID_SIZE);
7610 size += vn_sizeof_array_size(VK_UUID_SIZE);
7611 size += vn_sizeof_uint8_t_array(val->driverUUID, VK_UUID_SIZE);
7612 size += vn_sizeof_array_size(VK_LUID_SIZE);
7613 size += vn_sizeof_uint8_t_array(val->deviceLUID, VK_LUID_SIZE);
7614 size += vn_sizeof_uint32_t(&val->deviceNodeMask);
7615 size += vn_sizeof_VkBool32(&val->deviceLUIDValid);
7616 size += vn_sizeof_uint32_t(&val->subgroupSize);
7617 size += vn_sizeof_VkFlags(&val->subgroupSupportedStages);
7618 size += vn_sizeof_VkFlags(&val->subgroupSupportedOperations);
7619 size += vn_sizeof_VkBool32(&val->subgroupQuadOperationsInAllStages);
7620 size += vn_sizeof_VkPointClippingBehavior(&val->pointClippingBehavior);
7621 size += vn_sizeof_uint32_t(&val->maxMultiviewViewCount);
7622 size += vn_sizeof_uint32_t(&val->maxMultiviewInstanceIndex);
7623 size += vn_sizeof_VkBool32(&val->protectedNoFault);
7624 size += vn_sizeof_uint32_t(&val->maxPerSetDescriptors);
7625 size += vn_sizeof_VkDeviceSize(&val->maxMemoryAllocationSize);
7626 return size;
7627 }
7628
7629 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties * val)7630 vn_sizeof_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties *val)
7631 {
7632 size_t size = 0;
7633
7634 size += vn_sizeof_VkStructureType(&val->sType);
7635 size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext(val->pNext);
7636 size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self(val);
7637
7638 return size;
7639 }
7640
7641 static inline void
vn_decode_VkPhysicalDeviceVulkan11Properties_pnext(struct vn_cs_decoder * dec,const void * val)7642 vn_decode_VkPhysicalDeviceVulkan11Properties_pnext(struct vn_cs_decoder *dec, const void *val)
7643 {
7644 /* no known/supported struct */
7645 if (vn_decode_simple_pointer(dec))
7646 assert(false);
7647 }
7648
7649 static inline void
vn_decode_VkPhysicalDeviceVulkan11Properties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Properties * val)7650 vn_decode_VkPhysicalDeviceVulkan11Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Properties *val)
7651 {
7652 /* skip val->{sType,pNext} */
7653 {
7654 const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
7655 vn_decode_uint8_t_array(dec, val->deviceUUID, array_size);
7656 }
7657 {
7658 const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
7659 vn_decode_uint8_t_array(dec, val->driverUUID, array_size);
7660 }
7661 {
7662 const size_t array_size = vn_decode_array_size(dec, VK_LUID_SIZE);
7663 vn_decode_uint8_t_array(dec, val->deviceLUID, array_size);
7664 }
7665 vn_decode_uint32_t(dec, &val->deviceNodeMask);
7666 vn_decode_VkBool32(dec, &val->deviceLUIDValid);
7667 vn_decode_uint32_t(dec, &val->subgroupSize);
7668 vn_decode_VkFlags(dec, &val->subgroupSupportedStages);
7669 vn_decode_VkFlags(dec, &val->subgroupSupportedOperations);
7670 vn_decode_VkBool32(dec, &val->subgroupQuadOperationsInAllStages);
7671 vn_decode_VkPointClippingBehavior(dec, &val->pointClippingBehavior);
7672 vn_decode_uint32_t(dec, &val->maxMultiviewViewCount);
7673 vn_decode_uint32_t(dec, &val->maxMultiviewInstanceIndex);
7674 vn_decode_VkBool32(dec, &val->protectedNoFault);
7675 vn_decode_uint32_t(dec, &val->maxPerSetDescriptors);
7676 vn_decode_VkDeviceSize(dec, &val->maxMemoryAllocationSize);
7677 }
7678
7679 static inline void
vn_decode_VkPhysicalDeviceVulkan11Properties(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Properties * val)7680 vn_decode_VkPhysicalDeviceVulkan11Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Properties *val)
7681 {
7682 VkStructureType stype;
7683 vn_decode_VkStructureType(dec, &stype);
7684 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
7685
7686 assert(val->sType == stype);
7687 vn_decode_VkPhysicalDeviceVulkan11Properties_pnext(dec, val->pNext);
7688 vn_decode_VkPhysicalDeviceVulkan11Properties_self(dec, val);
7689 }
7690
7691 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext_partial(const void * val)7692 vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext_partial(const void *val)
7693 {
7694 /* no known/supported struct */
7695 return vn_sizeof_simple_pointer(NULL);
7696 }
7697
7698 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial(const VkPhysicalDeviceVulkan11Properties * val)7699 vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial(const VkPhysicalDeviceVulkan11Properties *val)
7700 {
7701 size_t size = 0;
7702 /* skip val->{sType,pNext} */
7703 /* skip val->deviceUUID */
7704 /* skip val->driverUUID */
7705 /* skip val->deviceLUID */
7706 /* skip val->deviceNodeMask */
7707 /* skip val->deviceLUIDValid */
7708 /* skip val->subgroupSize */
7709 /* skip val->subgroupSupportedStages */
7710 /* skip val->subgroupSupportedOperations */
7711 /* skip val->subgroupQuadOperationsInAllStages */
7712 /* skip val->pointClippingBehavior */
7713 /* skip val->maxMultiviewViewCount */
7714 /* skip val->maxMultiviewInstanceIndex */
7715 /* skip val->protectedNoFault */
7716 /* skip val->maxPerSetDescriptors */
7717 /* skip val->maxMemoryAllocationSize */
7718 return size;
7719 }
7720
7721 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_partial(const VkPhysicalDeviceVulkan11Properties * val)7722 vn_sizeof_VkPhysicalDeviceVulkan11Properties_partial(const VkPhysicalDeviceVulkan11Properties *val)
7723 {
7724 size_t size = 0;
7725
7726 size += vn_sizeof_VkStructureType(&val->sType);
7727 size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext_partial(val->pNext);
7728 size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial(val);
7729
7730 return size;
7731 }
7732
7733 static inline void
vn_encode_VkPhysicalDeviceVulkan11Properties_pnext_partial(struct vn_cs_encoder * enc,const void * val)7734 vn_encode_VkPhysicalDeviceVulkan11Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7735 {
7736 /* no known/supported struct */
7737 vn_encode_simple_pointer(enc, NULL);
7738 }
7739
7740 static inline void
vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Properties * val)7741 vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Properties *val)
7742 {
7743 /* skip val->{sType,pNext} */
7744 /* skip val->deviceUUID */
7745 /* skip val->driverUUID */
7746 /* skip val->deviceLUID */
7747 /* skip val->deviceNodeMask */
7748 /* skip val->deviceLUIDValid */
7749 /* skip val->subgroupSize */
7750 /* skip val->subgroupSupportedStages */
7751 /* skip val->subgroupSupportedOperations */
7752 /* skip val->subgroupQuadOperationsInAllStages */
7753 /* skip val->pointClippingBehavior */
7754 /* skip val->maxMultiviewViewCount */
7755 /* skip val->maxMultiviewInstanceIndex */
7756 /* skip val->protectedNoFault */
7757 /* skip val->maxPerSetDescriptors */
7758 /* skip val->maxMemoryAllocationSize */
7759 }
7760
7761 static inline void
vn_encode_VkPhysicalDeviceVulkan11Properties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Properties * val)7762 vn_encode_VkPhysicalDeviceVulkan11Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Properties *val)
7763 {
7764 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
7765 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES });
7766 vn_encode_VkPhysicalDeviceVulkan11Properties_pnext_partial(enc, val->pNext);
7767 vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(enc, val);
7768 }
7769
7770 /* struct VkPhysicalDeviceVulkan12Properties chain */
7771
7772 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext(const void * val)7773 vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext(const void *val)
7774 {
7775 /* no known/supported struct */
7776 return vn_sizeof_simple_pointer(NULL);
7777 }
7778
7779 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_self(const VkPhysicalDeviceVulkan12Properties * val)7780 vn_sizeof_VkPhysicalDeviceVulkan12Properties_self(const VkPhysicalDeviceVulkan12Properties *val)
7781 {
7782 size_t size = 0;
7783 /* skip val->{sType,pNext} */
7784 size += vn_sizeof_VkDriverId(&val->driverID);
7785 size += vn_sizeof_array_size(VK_MAX_DRIVER_NAME_SIZE);
7786 size += vn_sizeof_char_array(val->driverName, VK_MAX_DRIVER_NAME_SIZE);
7787 size += vn_sizeof_array_size(VK_MAX_DRIVER_INFO_SIZE);
7788 size += vn_sizeof_char_array(val->driverInfo, VK_MAX_DRIVER_INFO_SIZE);
7789 size += vn_sizeof_VkConformanceVersion(&val->conformanceVersion);
7790 size += vn_sizeof_VkShaderFloatControlsIndependence(&val->denormBehaviorIndependence);
7791 size += vn_sizeof_VkShaderFloatControlsIndependence(&val->roundingModeIndependence);
7792 size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat16);
7793 size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat32);
7794 size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat64);
7795 size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat16);
7796 size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat32);
7797 size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat64);
7798 size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat16);
7799 size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat32);
7800 size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat64);
7801 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat16);
7802 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat32);
7803 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat64);
7804 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat16);
7805 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat32);
7806 size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat64);
7807 size += vn_sizeof_uint32_t(&val->maxUpdateAfterBindDescriptorsInAllPools);
7808 size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexingNative);
7809 size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexingNative);
7810 size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexingNative);
7811 size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexingNative);
7812 size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexingNative);
7813 size += vn_sizeof_VkBool32(&val->robustBufferAccessUpdateAfterBind);
7814 size += vn_sizeof_VkBool32(&val->quadDivergentImplicitLod);
7815 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSamplers);
7816 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
7817 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
7818 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSampledImages);
7819 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageImages);
7820 size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
7821 size += vn_sizeof_uint32_t(&val->maxPerStageUpdateAfterBindResources);
7822 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSamplers);
7823 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffers);
7824 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
7825 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffers);
7826 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
7827 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSampledImages);
7828 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageImages);
7829 size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInputAttachments);
7830 size += vn_sizeof_VkFlags(&val->supportedDepthResolveModes);
7831 size += vn_sizeof_VkFlags(&val->supportedStencilResolveModes);
7832 size += vn_sizeof_VkBool32(&val->independentResolveNone);
7833 size += vn_sizeof_VkBool32(&val->independentResolve);
7834 size += vn_sizeof_VkBool32(&val->filterMinmaxSingleComponentFormats);
7835 size += vn_sizeof_VkBool32(&val->filterMinmaxImageComponentMapping);
7836 size += vn_sizeof_uint64_t(&val->maxTimelineSemaphoreValueDifference);
7837 size += vn_sizeof_VkFlags(&val->framebufferIntegerColorSampleCounts);
7838 return size;
7839 }
7840
7841 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties * val)7842 vn_sizeof_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties *val)
7843 {
7844 size_t size = 0;
7845
7846 size += vn_sizeof_VkStructureType(&val->sType);
7847 size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext(val->pNext);
7848 size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self(val);
7849
7850 return size;
7851 }
7852
7853 static inline void
vn_decode_VkPhysicalDeviceVulkan12Properties_pnext(struct vn_cs_decoder * dec,const void * val)7854 vn_decode_VkPhysicalDeviceVulkan12Properties_pnext(struct vn_cs_decoder *dec, const void *val)
7855 {
7856 /* no known/supported struct */
7857 if (vn_decode_simple_pointer(dec))
7858 assert(false);
7859 }
7860
7861 static inline void
vn_decode_VkPhysicalDeviceVulkan12Properties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Properties * val)7862 vn_decode_VkPhysicalDeviceVulkan12Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Properties *val)
7863 {
7864 /* skip val->{sType,pNext} */
7865 vn_decode_VkDriverId(dec, &val->driverID);
7866 {
7867 const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_NAME_SIZE);
7868 vn_decode_char_array(dec, val->driverName, array_size);
7869 }
7870 {
7871 const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_INFO_SIZE);
7872 vn_decode_char_array(dec, val->driverInfo, array_size);
7873 }
7874 vn_decode_VkConformanceVersion(dec, &val->conformanceVersion);
7875 vn_decode_VkShaderFloatControlsIndependence(dec, &val->denormBehaviorIndependence);
7876 vn_decode_VkShaderFloatControlsIndependence(dec, &val->roundingModeIndependence);
7877 vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat16);
7878 vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat32);
7879 vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat64);
7880 vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat16);
7881 vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat32);
7882 vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat64);
7883 vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat16);
7884 vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat32);
7885 vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat64);
7886 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat16);
7887 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat32);
7888 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat64);
7889 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat16);
7890 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat32);
7891 vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat64);
7892 vn_decode_uint32_t(dec, &val->maxUpdateAfterBindDescriptorsInAllPools);
7893 vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexingNative);
7894 vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexingNative);
7895 vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexingNative);
7896 vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexingNative);
7897 vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexingNative);
7898 vn_decode_VkBool32(dec, &val->robustBufferAccessUpdateAfterBind);
7899 vn_decode_VkBool32(dec, &val->quadDivergentImplicitLod);
7900 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSamplers);
7901 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
7902 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
7903 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSampledImages);
7904 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageImages);
7905 vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
7906 vn_decode_uint32_t(dec, &val->maxPerStageUpdateAfterBindResources);
7907 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSamplers);
7908 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffers);
7909 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
7910 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffers);
7911 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
7912 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSampledImages);
7913 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageImages);
7914 vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInputAttachments);
7915 vn_decode_VkFlags(dec, &val->supportedDepthResolveModes);
7916 vn_decode_VkFlags(dec, &val->supportedStencilResolveModes);
7917 vn_decode_VkBool32(dec, &val->independentResolveNone);
7918 vn_decode_VkBool32(dec, &val->independentResolve);
7919 vn_decode_VkBool32(dec, &val->filterMinmaxSingleComponentFormats);
7920 vn_decode_VkBool32(dec, &val->filterMinmaxImageComponentMapping);
7921 vn_decode_uint64_t(dec, &val->maxTimelineSemaphoreValueDifference);
7922 vn_decode_VkFlags(dec, &val->framebufferIntegerColorSampleCounts);
7923 }
7924
7925 static inline void
vn_decode_VkPhysicalDeviceVulkan12Properties(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Properties * val)7926 vn_decode_VkPhysicalDeviceVulkan12Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Properties *val)
7927 {
7928 VkStructureType stype;
7929 vn_decode_VkStructureType(dec, &stype);
7930 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
7931
7932 assert(val->sType == stype);
7933 vn_decode_VkPhysicalDeviceVulkan12Properties_pnext(dec, val->pNext);
7934 vn_decode_VkPhysicalDeviceVulkan12Properties_self(dec, val);
7935 }
7936
7937 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext_partial(const void * val)7938 vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext_partial(const void *val)
7939 {
7940 /* no known/supported struct */
7941 return vn_sizeof_simple_pointer(NULL);
7942 }
7943
7944 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial(const VkPhysicalDeviceVulkan12Properties * val)7945 vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial(const VkPhysicalDeviceVulkan12Properties *val)
7946 {
7947 size_t size = 0;
7948 /* skip val->{sType,pNext} */
7949 /* skip val->driverID */
7950 /* skip val->driverName */
7951 /* skip val->driverInfo */
7952 size += vn_sizeof_VkConformanceVersion_partial(&val->conformanceVersion);
7953 /* skip val->denormBehaviorIndependence */
7954 /* skip val->roundingModeIndependence */
7955 /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
7956 /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
7957 /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
7958 /* skip val->shaderDenormPreserveFloat16 */
7959 /* skip val->shaderDenormPreserveFloat32 */
7960 /* skip val->shaderDenormPreserveFloat64 */
7961 /* skip val->shaderDenormFlushToZeroFloat16 */
7962 /* skip val->shaderDenormFlushToZeroFloat32 */
7963 /* skip val->shaderDenormFlushToZeroFloat64 */
7964 /* skip val->shaderRoundingModeRTEFloat16 */
7965 /* skip val->shaderRoundingModeRTEFloat32 */
7966 /* skip val->shaderRoundingModeRTEFloat64 */
7967 /* skip val->shaderRoundingModeRTZFloat16 */
7968 /* skip val->shaderRoundingModeRTZFloat32 */
7969 /* skip val->shaderRoundingModeRTZFloat64 */
7970 /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
7971 /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
7972 /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
7973 /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
7974 /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
7975 /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
7976 /* skip val->robustBufferAccessUpdateAfterBind */
7977 /* skip val->quadDivergentImplicitLod */
7978 /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
7979 /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
7980 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
7981 /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
7982 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
7983 /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
7984 /* skip val->maxPerStageUpdateAfterBindResources */
7985 /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
7986 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
7987 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
7988 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
7989 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
7990 /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
7991 /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
7992 /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
7993 /* skip val->supportedDepthResolveModes */
7994 /* skip val->supportedStencilResolveModes */
7995 /* skip val->independentResolveNone */
7996 /* skip val->independentResolve */
7997 /* skip val->filterMinmaxSingleComponentFormats */
7998 /* skip val->filterMinmaxImageComponentMapping */
7999 /* skip val->maxTimelineSemaphoreValueDifference */
8000 /* skip val->framebufferIntegerColorSampleCounts */
8001 return size;
8002 }
8003
8004 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_partial(const VkPhysicalDeviceVulkan12Properties * val)8005 vn_sizeof_VkPhysicalDeviceVulkan12Properties_partial(const VkPhysicalDeviceVulkan12Properties *val)
8006 {
8007 size_t size = 0;
8008
8009 size += vn_sizeof_VkStructureType(&val->sType);
8010 size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext_partial(val->pNext);
8011 size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial(val);
8012
8013 return size;
8014 }
8015
8016 static inline void
vn_encode_VkPhysicalDeviceVulkan12Properties_pnext_partial(struct vn_cs_encoder * enc,const void * val)8017 vn_encode_VkPhysicalDeviceVulkan12Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
8018 {
8019 /* no known/supported struct */
8020 vn_encode_simple_pointer(enc, NULL);
8021 }
8022
8023 static inline void
vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Properties * val)8024 vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Properties *val)
8025 {
8026 /* skip val->{sType,pNext} */
8027 /* skip val->driverID */
8028 /* skip val->driverName */
8029 /* skip val->driverInfo */
8030 vn_encode_VkConformanceVersion_partial(enc, &val->conformanceVersion);
8031 /* skip val->denormBehaviorIndependence */
8032 /* skip val->roundingModeIndependence */
8033 /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
8034 /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
8035 /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
8036 /* skip val->shaderDenormPreserveFloat16 */
8037 /* skip val->shaderDenormPreserveFloat32 */
8038 /* skip val->shaderDenormPreserveFloat64 */
8039 /* skip val->shaderDenormFlushToZeroFloat16 */
8040 /* skip val->shaderDenormFlushToZeroFloat32 */
8041 /* skip val->shaderDenormFlushToZeroFloat64 */
8042 /* skip val->shaderRoundingModeRTEFloat16 */
8043 /* skip val->shaderRoundingModeRTEFloat32 */
8044 /* skip val->shaderRoundingModeRTEFloat64 */
8045 /* skip val->shaderRoundingModeRTZFloat16 */
8046 /* skip val->shaderRoundingModeRTZFloat32 */
8047 /* skip val->shaderRoundingModeRTZFloat64 */
8048 /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
8049 /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
8050 /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
8051 /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
8052 /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
8053 /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
8054 /* skip val->robustBufferAccessUpdateAfterBind */
8055 /* skip val->quadDivergentImplicitLod */
8056 /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
8057 /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
8058 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
8059 /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
8060 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
8061 /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
8062 /* skip val->maxPerStageUpdateAfterBindResources */
8063 /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
8064 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
8065 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
8066 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
8067 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
8068 /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
8069 /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
8070 /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
8071 /* skip val->supportedDepthResolveModes */
8072 /* skip val->supportedStencilResolveModes */
8073 /* skip val->independentResolveNone */
8074 /* skip val->independentResolve */
8075 /* skip val->filterMinmaxSingleComponentFormats */
8076 /* skip val->filterMinmaxImageComponentMapping */
8077 /* skip val->maxTimelineSemaphoreValueDifference */
8078 /* skip val->framebufferIntegerColorSampleCounts */
8079 }
8080
8081 static inline void
vn_encode_VkPhysicalDeviceVulkan12Properties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Properties * val)8082 vn_encode_VkPhysicalDeviceVulkan12Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Properties *val)
8083 {
8084 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
8085 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES });
8086 vn_encode_VkPhysicalDeviceVulkan12Properties_pnext_partial(enc, val->pNext);
8087 vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(enc, val);
8088 }
8089
8090 /* struct VkPhysicalDeviceProperties2 chain */
8091
8092 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_pnext(const void * val)8093 vn_sizeof_VkPhysicalDeviceProperties2_pnext(const void *val)
8094 {
8095 const VkBaseInStructure *pnext = val;
8096 size_t size = 0;
8097
8098 while (pnext) {
8099 switch ((int32_t)pnext->sType) {
8100 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
8101 size += vn_sizeof_simple_pointer(pnext);
8102 size += vn_sizeof_VkStructureType(&pnext->sType);
8103 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8104 size += vn_sizeof_VkPhysicalDeviceDriverProperties_self((const VkPhysicalDeviceDriverProperties *)pnext);
8105 return size;
8106 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
8107 size += vn_sizeof_simple_pointer(pnext);
8108 size += vn_sizeof_VkStructureType(&pnext->sType);
8109 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8110 size += vn_sizeof_VkPhysicalDeviceIDProperties_self((const VkPhysicalDeviceIDProperties *)pnext);
8111 return size;
8112 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
8113 size += vn_sizeof_simple_pointer(pnext);
8114 size += vn_sizeof_VkStructureType(&pnext->sType);
8115 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8116 size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self((const VkPhysicalDeviceMultiviewProperties *)pnext);
8117 return size;
8118 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
8119 size += vn_sizeof_simple_pointer(pnext);
8120 size += vn_sizeof_VkStructureType(&pnext->sType);
8121 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8122 size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self((const VkPhysicalDeviceSubgroupProperties *)pnext);
8123 return size;
8124 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
8125 size += vn_sizeof_simple_pointer(pnext);
8126 size += vn_sizeof_VkStructureType(&pnext->sType);
8127 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8128 size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self((const VkPhysicalDevicePointClippingProperties *)pnext);
8129 return size;
8130 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
8131 size += vn_sizeof_simple_pointer(pnext);
8132 size += vn_sizeof_VkStructureType(&pnext->sType);
8133 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8134 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self((const VkPhysicalDeviceProtectedMemoryProperties *)pnext);
8135 return size;
8136 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
8137 size += vn_sizeof_simple_pointer(pnext);
8138 size += vn_sizeof_VkStructureType(&pnext->sType);
8139 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8140 size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self((const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
8141 return size;
8142 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
8143 size += vn_sizeof_simple_pointer(pnext);
8144 size += vn_sizeof_VkStructureType(&pnext->sType);
8145 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8146 size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self((const VkPhysicalDeviceMaintenance3Properties *)pnext);
8147 return size;
8148 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
8149 size += vn_sizeof_simple_pointer(pnext);
8150 size += vn_sizeof_VkStructureType(&pnext->sType);
8151 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8152 size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self((const VkPhysicalDeviceFloatControlsProperties *)pnext);
8153 return size;
8154 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
8155 size += vn_sizeof_simple_pointer(pnext);
8156 size += vn_sizeof_VkStructureType(&pnext->sType);
8157 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8158 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self((const VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
8159 return size;
8160 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
8161 size += vn_sizeof_simple_pointer(pnext);
8162 size += vn_sizeof_VkStructureType(&pnext->sType);
8163 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8164 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self((const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
8165 return size;
8166 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
8167 size += vn_sizeof_simple_pointer(pnext);
8168 size += vn_sizeof_VkStructureType(&pnext->sType);
8169 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8170 size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self((const VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
8171 return size;
8172 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
8173 size += vn_sizeof_simple_pointer(pnext);
8174 size += vn_sizeof_VkStructureType(&pnext->sType);
8175 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8176 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self((const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
8177 return size;
8178 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
8179 size += vn_sizeof_simple_pointer(pnext);
8180 size += vn_sizeof_VkStructureType(&pnext->sType);
8181 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8182 size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self((const VkPhysicalDeviceVulkan11Properties *)pnext);
8183 return size;
8184 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
8185 size += vn_sizeof_simple_pointer(pnext);
8186 size += vn_sizeof_VkStructureType(&pnext->sType);
8187 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8188 size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self((const VkPhysicalDeviceVulkan12Properties *)pnext);
8189 return size;
8190 default:
8191 /* ignore unknown/unsupported struct */
8192 break;
8193 }
8194 pnext = pnext->pNext;
8195 }
8196
8197 return vn_sizeof_simple_pointer(NULL);
8198 }
8199
8200 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_self(const VkPhysicalDeviceProperties2 * val)8201 vn_sizeof_VkPhysicalDeviceProperties2_self(const VkPhysicalDeviceProperties2 *val)
8202 {
8203 size_t size = 0;
8204 /* skip val->{sType,pNext} */
8205 size += vn_sizeof_VkPhysicalDeviceProperties(&val->properties);
8206 return size;
8207 }
8208
8209 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2 * val)8210 vn_sizeof_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2 *val)
8211 {
8212 size_t size = 0;
8213
8214 size += vn_sizeof_VkStructureType(&val->sType);
8215 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(val->pNext);
8216 size += vn_sizeof_VkPhysicalDeviceProperties2_self(val);
8217
8218 return size;
8219 }
8220
8221 static inline void
vn_decode_VkPhysicalDeviceProperties2_pnext(struct vn_cs_decoder * dec,const void * val)8222 vn_decode_VkPhysicalDeviceProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
8223 {
8224 VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
8225 VkStructureType stype;
8226
8227 if (!vn_decode_simple_pointer(dec))
8228 return;
8229
8230 vn_decode_VkStructureType(dec, &stype);
8231 while (true) {
8232 assert(pnext);
8233 if (pnext->sType == stype)
8234 break;
8235 }
8236
8237 switch ((int32_t)pnext->sType) {
8238 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
8239 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8240 vn_decode_VkPhysicalDeviceDriverProperties_self(dec, (VkPhysicalDeviceDriverProperties *)pnext);
8241 break;
8242 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
8243 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8244 vn_decode_VkPhysicalDeviceIDProperties_self(dec, (VkPhysicalDeviceIDProperties *)pnext);
8245 break;
8246 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
8247 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8248 vn_decode_VkPhysicalDeviceMultiviewProperties_self(dec, (VkPhysicalDeviceMultiviewProperties *)pnext);
8249 break;
8250 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
8251 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8252 vn_decode_VkPhysicalDeviceSubgroupProperties_self(dec, (VkPhysicalDeviceSubgroupProperties *)pnext);
8253 break;
8254 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
8255 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8256 vn_decode_VkPhysicalDevicePointClippingProperties_self(dec, (VkPhysicalDevicePointClippingProperties *)pnext);
8257 break;
8258 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
8259 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8260 vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(dec, (VkPhysicalDeviceProtectedMemoryProperties *)pnext);
8261 break;
8262 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
8263 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8264 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(dec, (VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
8265 break;
8266 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
8267 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8268 vn_decode_VkPhysicalDeviceMaintenance3Properties_self(dec, (VkPhysicalDeviceMaintenance3Properties *)pnext);
8269 break;
8270 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
8271 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8272 vn_decode_VkPhysicalDeviceFloatControlsProperties_self(dec, (VkPhysicalDeviceFloatControlsProperties *)pnext);
8273 break;
8274 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
8275 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8276 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(dec, (VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
8277 break;
8278 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
8279 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8280 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(dec, (VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
8281 break;
8282 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
8283 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8284 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(dec, (VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
8285 break;
8286 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
8287 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8288 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(dec, (VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
8289 break;
8290 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
8291 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8292 vn_decode_VkPhysicalDeviceVulkan11Properties_self(dec, (VkPhysicalDeviceVulkan11Properties *)pnext);
8293 break;
8294 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
8295 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8296 vn_decode_VkPhysicalDeviceVulkan12Properties_self(dec, (VkPhysicalDeviceVulkan12Properties *)pnext);
8297 break;
8298 default:
8299 assert(false);
8300 break;
8301 }
8302 }
8303
8304 static inline void
vn_decode_VkPhysicalDeviceProperties2_self(struct vn_cs_decoder * dec,VkPhysicalDeviceProperties2 * val)8305 vn_decode_VkPhysicalDeviceProperties2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties2 *val)
8306 {
8307 /* skip val->{sType,pNext} */
8308 vn_decode_VkPhysicalDeviceProperties(dec, &val->properties);
8309 }
8310
8311 static inline void
vn_decode_VkPhysicalDeviceProperties2(struct vn_cs_decoder * dec,VkPhysicalDeviceProperties2 * val)8312 vn_decode_VkPhysicalDeviceProperties2(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties2 *val)
8313 {
8314 VkStructureType stype;
8315 vn_decode_VkStructureType(dec, &stype);
8316 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);
8317
8318 assert(val->sType == stype);
8319 vn_decode_VkPhysicalDeviceProperties2_pnext(dec, val->pNext);
8320 vn_decode_VkPhysicalDeviceProperties2_self(dec, val);
8321 }
8322
8323 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(const void * val)8324 vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(const void *val)
8325 {
8326 const VkBaseInStructure *pnext = val;
8327 size_t size = 0;
8328
8329 while (pnext) {
8330 switch ((int32_t)pnext->sType) {
8331 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
8332 size += vn_sizeof_simple_pointer(pnext);
8333 size += vn_sizeof_VkStructureType(&pnext->sType);
8334 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8335 size += vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial((const VkPhysicalDeviceDriverProperties *)pnext);
8336 return size;
8337 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
8338 size += vn_sizeof_simple_pointer(pnext);
8339 size += vn_sizeof_VkStructureType(&pnext->sType);
8340 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8341 size += vn_sizeof_VkPhysicalDeviceIDProperties_self_partial((const VkPhysicalDeviceIDProperties *)pnext);
8342 return size;
8343 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
8344 size += vn_sizeof_simple_pointer(pnext);
8345 size += vn_sizeof_VkStructureType(&pnext->sType);
8346 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8347 size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial((const VkPhysicalDeviceMultiviewProperties *)pnext);
8348 return size;
8349 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
8350 size += vn_sizeof_simple_pointer(pnext);
8351 size += vn_sizeof_VkStructureType(&pnext->sType);
8352 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8353 size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial((const VkPhysicalDeviceSubgroupProperties *)pnext);
8354 return size;
8355 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
8356 size += vn_sizeof_simple_pointer(pnext);
8357 size += vn_sizeof_VkStructureType(&pnext->sType);
8358 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8359 size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial((const VkPhysicalDevicePointClippingProperties *)pnext);
8360 return size;
8361 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
8362 size += vn_sizeof_simple_pointer(pnext);
8363 size += vn_sizeof_VkStructureType(&pnext->sType);
8364 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8365 size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial((const VkPhysicalDeviceProtectedMemoryProperties *)pnext);
8366 return size;
8367 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
8368 size += vn_sizeof_simple_pointer(pnext);
8369 size += vn_sizeof_VkStructureType(&pnext->sType);
8370 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8371 size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial((const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
8372 return size;
8373 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
8374 size += vn_sizeof_simple_pointer(pnext);
8375 size += vn_sizeof_VkStructureType(&pnext->sType);
8376 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8377 size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial((const VkPhysicalDeviceMaintenance3Properties *)pnext);
8378 return size;
8379 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
8380 size += vn_sizeof_simple_pointer(pnext);
8381 size += vn_sizeof_VkStructureType(&pnext->sType);
8382 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8383 size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial((const VkPhysicalDeviceFloatControlsProperties *)pnext);
8384 return size;
8385 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
8386 size += vn_sizeof_simple_pointer(pnext);
8387 size += vn_sizeof_VkStructureType(&pnext->sType);
8388 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8389 size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial((const VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
8390 return size;
8391 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
8392 size += vn_sizeof_simple_pointer(pnext);
8393 size += vn_sizeof_VkStructureType(&pnext->sType);
8394 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8395 size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial((const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
8396 return size;
8397 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
8398 size += vn_sizeof_simple_pointer(pnext);
8399 size += vn_sizeof_VkStructureType(&pnext->sType);
8400 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8401 size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial((const VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
8402 return size;
8403 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
8404 size += vn_sizeof_simple_pointer(pnext);
8405 size += vn_sizeof_VkStructureType(&pnext->sType);
8406 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8407 size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial((const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
8408 return size;
8409 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
8410 size += vn_sizeof_simple_pointer(pnext);
8411 size += vn_sizeof_VkStructureType(&pnext->sType);
8412 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8413 size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial((const VkPhysicalDeviceVulkan11Properties *)pnext);
8414 return size;
8415 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
8416 size += vn_sizeof_simple_pointer(pnext);
8417 size += vn_sizeof_VkStructureType(&pnext->sType);
8418 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8419 size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial((const VkPhysicalDeviceVulkan12Properties *)pnext);
8420 return size;
8421 default:
8422 /* ignore unknown/unsupported struct */
8423 break;
8424 }
8425 pnext = pnext->pNext;
8426 }
8427
8428 return vn_sizeof_simple_pointer(NULL);
8429 }
8430
8431 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_self_partial(const VkPhysicalDeviceProperties2 * val)8432 vn_sizeof_VkPhysicalDeviceProperties2_self_partial(const VkPhysicalDeviceProperties2 *val)
8433 {
8434 size_t size = 0;
8435 /* skip val->{sType,pNext} */
8436 size += vn_sizeof_VkPhysicalDeviceProperties_partial(&val->properties);
8437 return size;
8438 }
8439
8440 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_partial(const VkPhysicalDeviceProperties2 * val)8441 vn_sizeof_VkPhysicalDeviceProperties2_partial(const VkPhysicalDeviceProperties2 *val)
8442 {
8443 size_t size = 0;
8444
8445 size += vn_sizeof_VkStructureType(&val->sType);
8446 size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(val->pNext);
8447 size += vn_sizeof_VkPhysicalDeviceProperties2_self_partial(val);
8448
8449 return size;
8450 }
8451
8452 static inline void
vn_encode_VkPhysicalDeviceProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)8453 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
8454 {
8455 const VkBaseInStructure *pnext = val;
8456
8457 while (pnext) {
8458 switch ((int32_t)pnext->sType) {
8459 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
8460 vn_encode_simple_pointer(enc, pnext);
8461 vn_encode_VkStructureType(enc, &pnext->sType);
8462 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8463 vn_encode_VkPhysicalDeviceDriverProperties_self_partial(enc, (const VkPhysicalDeviceDriverProperties *)pnext);
8464 return;
8465 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
8466 vn_encode_simple_pointer(enc, pnext);
8467 vn_encode_VkStructureType(enc, &pnext->sType);
8468 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8469 vn_encode_VkPhysicalDeviceIDProperties_self_partial(enc, (const VkPhysicalDeviceIDProperties *)pnext);
8470 return;
8471 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
8472 vn_encode_simple_pointer(enc, pnext);
8473 vn_encode_VkStructureType(enc, &pnext->sType);
8474 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8475 vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(enc, (const VkPhysicalDeviceMultiviewProperties *)pnext);
8476 return;
8477 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
8478 vn_encode_simple_pointer(enc, pnext);
8479 vn_encode_VkStructureType(enc, &pnext->sType);
8480 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8481 vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(enc, (const VkPhysicalDeviceSubgroupProperties *)pnext);
8482 return;
8483 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
8484 vn_encode_simple_pointer(enc, pnext);
8485 vn_encode_VkStructureType(enc, &pnext->sType);
8486 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8487 vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(enc, (const VkPhysicalDevicePointClippingProperties *)pnext);
8488 return;
8489 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
8490 vn_encode_simple_pointer(enc, pnext);
8491 vn_encode_VkStructureType(enc, &pnext->sType);
8492 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8493 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(enc, (const VkPhysicalDeviceProtectedMemoryProperties *)pnext);
8494 return;
8495 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
8496 vn_encode_simple_pointer(enc, pnext);
8497 vn_encode_VkStructureType(enc, &pnext->sType);
8498 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8499 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(enc, (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
8500 return;
8501 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
8502 vn_encode_simple_pointer(enc, pnext);
8503 vn_encode_VkStructureType(enc, &pnext->sType);
8504 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8505 vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(enc, (const VkPhysicalDeviceMaintenance3Properties *)pnext);
8506 return;
8507 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
8508 vn_encode_simple_pointer(enc, pnext);
8509 vn_encode_VkStructureType(enc, &pnext->sType);
8510 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8511 vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(enc, (const VkPhysicalDeviceFloatControlsProperties *)pnext);
8512 return;
8513 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
8514 vn_encode_simple_pointer(enc, pnext);
8515 vn_encode_VkStructureType(enc, &pnext->sType);
8516 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8517 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(enc, (const VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
8518 return;
8519 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
8520 vn_encode_simple_pointer(enc, pnext);
8521 vn_encode_VkStructureType(enc, &pnext->sType);
8522 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8523 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(enc, (const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
8524 return;
8525 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
8526 vn_encode_simple_pointer(enc, pnext);
8527 vn_encode_VkStructureType(enc, &pnext->sType);
8528 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8529 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(enc, (const VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
8530 return;
8531 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
8532 vn_encode_simple_pointer(enc, pnext);
8533 vn_encode_VkStructureType(enc, &pnext->sType);
8534 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8535 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
8536 return;
8537 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
8538 vn_encode_simple_pointer(enc, pnext);
8539 vn_encode_VkStructureType(enc, &pnext->sType);
8540 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8541 vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(enc, (const VkPhysicalDeviceVulkan11Properties *)pnext);
8542 return;
8543 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
8544 vn_encode_simple_pointer(enc, pnext);
8545 vn_encode_VkStructureType(enc, &pnext->sType);
8546 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8547 vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(enc, (const VkPhysicalDeviceVulkan12Properties *)pnext);
8548 return;
8549 default:
8550 /* ignore unknown/unsupported struct */
8551 break;
8552 }
8553 pnext = pnext->pNext;
8554 }
8555
8556 vn_encode_simple_pointer(enc, NULL);
8557 }
8558
8559 static inline void
vn_encode_VkPhysicalDeviceProperties2_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProperties2 * val)8560 vn_encode_VkPhysicalDeviceProperties2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties2 *val)
8561 {
8562 /* skip val->{sType,pNext} */
8563 vn_encode_VkPhysicalDeviceProperties_partial(enc, &val->properties);
8564 }
8565
8566 static inline void
vn_encode_VkPhysicalDeviceProperties2_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProperties2 * val)8567 vn_encode_VkPhysicalDeviceProperties2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties2 *val)
8568 {
8569 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);
8570 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 });
8571 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, val->pNext);
8572 vn_encode_VkPhysicalDeviceProperties2_self_partial(enc, val);
8573 }
8574
8575 /* struct VkDrmFormatModifierPropertiesEXT */
8576
8577 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT * val)8578 vn_sizeof_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT *val)
8579 {
8580 size_t size = 0;
8581 size += vn_sizeof_uint64_t(&val->drmFormatModifier);
8582 size += vn_sizeof_uint32_t(&val->drmFormatModifierPlaneCount);
8583 size += vn_sizeof_VkFlags(&val->drmFormatModifierTilingFeatures);
8584 return size;
8585 }
8586
8587 static inline void
vn_decode_VkDrmFormatModifierPropertiesEXT(struct vn_cs_decoder * dec,VkDrmFormatModifierPropertiesEXT * val)8588 vn_decode_VkDrmFormatModifierPropertiesEXT(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesEXT *val)
8589 {
8590 vn_decode_uint64_t(dec, &val->drmFormatModifier);
8591 vn_decode_uint32_t(dec, &val->drmFormatModifierPlaneCount);
8592 vn_decode_VkFlags(dec, &val->drmFormatModifierTilingFeatures);
8593 }
8594
8595 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesEXT_partial(const VkDrmFormatModifierPropertiesEXT * val)8596 vn_sizeof_VkDrmFormatModifierPropertiesEXT_partial(const VkDrmFormatModifierPropertiesEXT *val)
8597 {
8598 size_t size = 0;
8599 /* skip val->drmFormatModifier */
8600 /* skip val->drmFormatModifierPlaneCount */
8601 /* skip val->drmFormatModifierTilingFeatures */
8602 return size;
8603 }
8604
8605 static inline void
vn_encode_VkDrmFormatModifierPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkDrmFormatModifierPropertiesEXT * val)8606 vn_encode_VkDrmFormatModifierPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesEXT *val)
8607 {
8608 /* skip val->drmFormatModifier */
8609 /* skip val->drmFormatModifierPlaneCount */
8610 /* skip val->drmFormatModifierTilingFeatures */
8611 }
8612
8613 /* struct VkDrmFormatModifierPropertiesListEXT chain */
8614
8615 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext(const void * val)8616 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext(const void *val)
8617 {
8618 /* no known/supported struct */
8619 return vn_sizeof_simple_pointer(NULL);
8620 }
8621
8622 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self(const VkDrmFormatModifierPropertiesListEXT * val)8623 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self(const VkDrmFormatModifierPropertiesListEXT *val)
8624 {
8625 size_t size = 0;
8626 /* skip val->{sType,pNext} */
8627 size += vn_sizeof_uint32_t(&val->drmFormatModifierCount);
8628 if (val->pDrmFormatModifierProperties) {
8629 size += vn_sizeof_array_size(val->drmFormatModifierCount);
8630 for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
8631 size += vn_sizeof_VkDrmFormatModifierPropertiesEXT(&val->pDrmFormatModifierProperties[i]);
8632 } else {
8633 size += vn_sizeof_array_size(0);
8634 }
8635 return size;
8636 }
8637
8638 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT * val)8639 vn_sizeof_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT *val)
8640 {
8641 size_t size = 0;
8642
8643 size += vn_sizeof_VkStructureType(&val->sType);
8644 size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext(val->pNext);
8645 size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self(val);
8646
8647 return size;
8648 }
8649
8650 static inline void
vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext(struct vn_cs_decoder * dec,const void * val)8651 vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext(struct vn_cs_decoder *dec, const void *val)
8652 {
8653 /* no known/supported struct */
8654 if (vn_decode_simple_pointer(dec))
8655 assert(false);
8656 }
8657
8658 static inline void
vn_decode_VkDrmFormatModifierPropertiesListEXT_self(struct vn_cs_decoder * dec,VkDrmFormatModifierPropertiesListEXT * val)8659 vn_decode_VkDrmFormatModifierPropertiesListEXT_self(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesListEXT *val)
8660 {
8661 /* skip val->{sType,pNext} */
8662 vn_decode_uint32_t(dec, &val->drmFormatModifierCount);
8663 if (vn_peek_array_size(dec)) {
8664 const uint32_t iter_count = vn_decode_array_size(dec, val->drmFormatModifierCount);
8665 for (uint32_t i = 0; i < iter_count; i++)
8666 vn_decode_VkDrmFormatModifierPropertiesEXT(dec, &val->pDrmFormatModifierProperties[i]);
8667 } else {
8668 vn_decode_array_size_unchecked(dec);
8669 val->pDrmFormatModifierProperties = NULL;
8670 }
8671 }
8672
8673 static inline void
vn_decode_VkDrmFormatModifierPropertiesListEXT(struct vn_cs_decoder * dec,VkDrmFormatModifierPropertiesListEXT * val)8674 vn_decode_VkDrmFormatModifierPropertiesListEXT(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesListEXT *val)
8675 {
8676 VkStructureType stype;
8677 vn_decode_VkStructureType(dec, &stype);
8678 assert(stype == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT);
8679
8680 assert(val->sType == stype);
8681 vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext(dec, val->pNext);
8682 vn_decode_VkDrmFormatModifierPropertiesListEXT_self(dec, val);
8683 }
8684
8685 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext_partial(const void * val)8686 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext_partial(const void *val)
8687 {
8688 /* no known/supported struct */
8689 return vn_sizeof_simple_pointer(NULL);
8690 }
8691
8692 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial(const VkDrmFormatModifierPropertiesListEXT * val)8693 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial(const VkDrmFormatModifierPropertiesListEXT *val)
8694 {
8695 size_t size = 0;
8696 /* skip val->{sType,pNext} */
8697 /* WA1: size += vn_sizeof_uint32_t(&val->drmFormatModifierCount) */(void)0;
8698 if (val->pDrmFormatModifierProperties) {
8699 size += vn_sizeof_array_size(val->drmFormatModifierCount);
8700 for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
8701 size += vn_sizeof_VkDrmFormatModifierPropertiesEXT_partial(&val->pDrmFormatModifierProperties[i]);
8702 } else {
8703 size += vn_sizeof_array_size(0);
8704 }
8705 return size;
8706 }
8707
8708 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_partial(const VkDrmFormatModifierPropertiesListEXT * val)8709 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_partial(const VkDrmFormatModifierPropertiesListEXT *val)
8710 {
8711 size_t size = 0;
8712
8713 size += vn_sizeof_VkStructureType(&val->sType);
8714 size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext_partial(val->pNext);
8715 size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial(val);
8716
8717 return size;
8718 }
8719
8720 static inline void
vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)8721 vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
8722 {
8723 /* no known/supported struct */
8724 vn_encode_simple_pointer(enc, NULL);
8725 }
8726
8727 static inline void
vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(struct vn_cs_encoder * enc,const VkDrmFormatModifierPropertiesListEXT * val)8728 vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesListEXT *val)
8729 {
8730 /* skip val->{sType,pNext} */
8731 /* WA1: vn_encode_uint32_t(enc, &val->drmFormatModifierCount) */(void)0;
8732 if (val->pDrmFormatModifierProperties) {
8733 vn_encode_array_size(enc, val->drmFormatModifierCount);
8734 for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
8735 vn_encode_VkDrmFormatModifierPropertiesEXT_partial(enc, &val->pDrmFormatModifierProperties[i]);
8736 } else {
8737 vn_encode_array_size(enc, 0);
8738 }
8739 }
8740
8741 static inline void
vn_encode_VkDrmFormatModifierPropertiesListEXT_partial(struct vn_cs_encoder * enc,const VkDrmFormatModifierPropertiesListEXT * val)8742 vn_encode_VkDrmFormatModifierPropertiesListEXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesListEXT *val)
8743 {
8744 assert(val->sType == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT);
8745 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT });
8746 vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext_partial(enc, val->pNext);
8747 vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(enc, val);
8748 }
8749
8750 /* struct VkFormatProperties2 chain */
8751
8752 static inline size_t
vn_sizeof_VkFormatProperties2_pnext(const void * val)8753 vn_sizeof_VkFormatProperties2_pnext(const void *val)
8754 {
8755 const VkBaseInStructure *pnext = val;
8756 size_t size = 0;
8757
8758 while (pnext) {
8759 switch ((int32_t)pnext->sType) {
8760 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
8761 size += vn_sizeof_simple_pointer(pnext);
8762 size += vn_sizeof_VkStructureType(&pnext->sType);
8763 size += vn_sizeof_VkFormatProperties2_pnext(pnext->pNext);
8764 size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self((const VkDrmFormatModifierPropertiesListEXT *)pnext);
8765 return size;
8766 default:
8767 /* ignore unknown/unsupported struct */
8768 break;
8769 }
8770 pnext = pnext->pNext;
8771 }
8772
8773 return vn_sizeof_simple_pointer(NULL);
8774 }
8775
8776 static inline size_t
vn_sizeof_VkFormatProperties2_self(const VkFormatProperties2 * val)8777 vn_sizeof_VkFormatProperties2_self(const VkFormatProperties2 *val)
8778 {
8779 size_t size = 0;
8780 /* skip val->{sType,pNext} */
8781 size += vn_sizeof_VkFormatProperties(&val->formatProperties);
8782 return size;
8783 }
8784
8785 static inline size_t
vn_sizeof_VkFormatProperties2(const VkFormatProperties2 * val)8786 vn_sizeof_VkFormatProperties2(const VkFormatProperties2 *val)
8787 {
8788 size_t size = 0;
8789
8790 size += vn_sizeof_VkStructureType(&val->sType);
8791 size += vn_sizeof_VkFormatProperties2_pnext(val->pNext);
8792 size += vn_sizeof_VkFormatProperties2_self(val);
8793
8794 return size;
8795 }
8796
8797 static inline void
vn_decode_VkFormatProperties2_pnext(struct vn_cs_decoder * dec,const void * val)8798 vn_decode_VkFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
8799 {
8800 VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
8801 VkStructureType stype;
8802
8803 if (!vn_decode_simple_pointer(dec))
8804 return;
8805
8806 vn_decode_VkStructureType(dec, &stype);
8807 while (true) {
8808 assert(pnext);
8809 if (pnext->sType == stype)
8810 break;
8811 }
8812
8813 switch ((int32_t)pnext->sType) {
8814 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
8815 vn_decode_VkFormatProperties2_pnext(dec, pnext->pNext);
8816 vn_decode_VkDrmFormatModifierPropertiesListEXT_self(dec, (VkDrmFormatModifierPropertiesListEXT *)pnext);
8817 break;
8818 default:
8819 assert(false);
8820 break;
8821 }
8822 }
8823
8824 static inline void
vn_decode_VkFormatProperties2_self(struct vn_cs_decoder * dec,VkFormatProperties2 * val)8825 vn_decode_VkFormatProperties2_self(struct vn_cs_decoder *dec, VkFormatProperties2 *val)
8826 {
8827 /* skip val->{sType,pNext} */
8828 vn_decode_VkFormatProperties(dec, &val->formatProperties);
8829 }
8830
8831 static inline void
vn_decode_VkFormatProperties2(struct vn_cs_decoder * dec,VkFormatProperties2 * val)8832 vn_decode_VkFormatProperties2(struct vn_cs_decoder *dec, VkFormatProperties2 *val)
8833 {
8834 VkStructureType stype;
8835 vn_decode_VkStructureType(dec, &stype);
8836 assert(stype == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
8837
8838 assert(val->sType == stype);
8839 vn_decode_VkFormatProperties2_pnext(dec, val->pNext);
8840 vn_decode_VkFormatProperties2_self(dec, val);
8841 }
8842
8843 static inline size_t
vn_sizeof_VkFormatProperties2_pnext_partial(const void * val)8844 vn_sizeof_VkFormatProperties2_pnext_partial(const void *val)
8845 {
8846 const VkBaseInStructure *pnext = val;
8847 size_t size = 0;
8848
8849 while (pnext) {
8850 switch ((int32_t)pnext->sType) {
8851 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
8852 size += vn_sizeof_simple_pointer(pnext);
8853 size += vn_sizeof_VkStructureType(&pnext->sType);
8854 size += vn_sizeof_VkFormatProperties2_pnext_partial(pnext->pNext);
8855 size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial((const VkDrmFormatModifierPropertiesListEXT *)pnext);
8856 return size;
8857 default:
8858 /* ignore unknown/unsupported struct */
8859 break;
8860 }
8861 pnext = pnext->pNext;
8862 }
8863
8864 return vn_sizeof_simple_pointer(NULL);
8865 }
8866
8867 static inline size_t
vn_sizeof_VkFormatProperties2_self_partial(const VkFormatProperties2 * val)8868 vn_sizeof_VkFormatProperties2_self_partial(const VkFormatProperties2 *val)
8869 {
8870 size_t size = 0;
8871 /* skip val->{sType,pNext} */
8872 size += vn_sizeof_VkFormatProperties_partial(&val->formatProperties);
8873 return size;
8874 }
8875
8876 static inline size_t
vn_sizeof_VkFormatProperties2_partial(const VkFormatProperties2 * val)8877 vn_sizeof_VkFormatProperties2_partial(const VkFormatProperties2 *val)
8878 {
8879 size_t size = 0;
8880
8881 size += vn_sizeof_VkStructureType(&val->sType);
8882 size += vn_sizeof_VkFormatProperties2_pnext_partial(val->pNext);
8883 size += vn_sizeof_VkFormatProperties2_self_partial(val);
8884
8885 return size;
8886 }
8887
8888 static inline void
vn_encode_VkFormatProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)8889 vn_encode_VkFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
8890 {
8891 const VkBaseInStructure *pnext = val;
8892
8893 while (pnext) {
8894 switch ((int32_t)pnext->sType) {
8895 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
8896 vn_encode_simple_pointer(enc, pnext);
8897 vn_encode_VkStructureType(enc, &pnext->sType);
8898 vn_encode_VkFormatProperties2_pnext_partial(enc, pnext->pNext);
8899 vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(enc, (const VkDrmFormatModifierPropertiesListEXT *)pnext);
8900 return;
8901 default:
8902 /* ignore unknown/unsupported struct */
8903 break;
8904 }
8905 pnext = pnext->pNext;
8906 }
8907
8908 vn_encode_simple_pointer(enc, NULL);
8909 }
8910
8911 static inline void
vn_encode_VkFormatProperties2_self_partial(struct vn_cs_encoder * enc,const VkFormatProperties2 * val)8912 vn_encode_VkFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkFormatProperties2 *val)
8913 {
8914 /* skip val->{sType,pNext} */
8915 vn_encode_VkFormatProperties_partial(enc, &val->formatProperties);
8916 }
8917
8918 static inline void
vn_encode_VkFormatProperties2_partial(struct vn_cs_encoder * enc,const VkFormatProperties2 * val)8919 vn_encode_VkFormatProperties2_partial(struct vn_cs_encoder *enc, const VkFormatProperties2 *val)
8920 {
8921 assert(val->sType == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
8922 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 });
8923 vn_encode_VkFormatProperties2_pnext_partial(enc, val->pNext);
8924 vn_encode_VkFormatProperties2_self_partial(enc, val);
8925 }
8926
8927 /* struct VkPhysicalDeviceExternalImageFormatInfo chain */
8928
8929 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_pnext(const void * val)8930 vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_pnext(const void *val)
8931 {
8932 /* no known/supported struct */
8933 return vn_sizeof_simple_pointer(NULL);
8934 }
8935
8936 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self(const VkPhysicalDeviceExternalImageFormatInfo * val)8937 vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self(const VkPhysicalDeviceExternalImageFormatInfo *val)
8938 {
8939 size_t size = 0;
8940 /* skip val->{sType,pNext} */
8941 size += vn_sizeof_VkExternalMemoryHandleTypeFlagBits(&val->handleType);
8942 return size;
8943 }
8944
8945 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo * val)8946 vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo *val)
8947 {
8948 size_t size = 0;
8949
8950 size += vn_sizeof_VkStructureType(&val->sType);
8951 size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_pnext(val->pNext);
8952 size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self(val);
8953
8954 return size;
8955 }
8956
8957 static inline void
vn_encode_VkPhysicalDeviceExternalImageFormatInfo_pnext(struct vn_cs_encoder * enc,const void * val)8958 vn_encode_VkPhysicalDeviceExternalImageFormatInfo_pnext(struct vn_cs_encoder *enc, const void *val)
8959 {
8960 /* no known/supported struct */
8961 vn_encode_simple_pointer(enc, NULL);
8962 }
8963
8964 static inline void
vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalImageFormatInfo * val)8965 vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalImageFormatInfo *val)
8966 {
8967 /* skip val->{sType,pNext} */
8968 vn_encode_VkExternalMemoryHandleTypeFlagBits(enc, &val->handleType);
8969 }
8970
8971 static inline void
vn_encode_VkPhysicalDeviceExternalImageFormatInfo(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalImageFormatInfo * val)8972 vn_encode_VkPhysicalDeviceExternalImageFormatInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalImageFormatInfo *val)
8973 {
8974 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO);
8975 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO });
8976 vn_encode_VkPhysicalDeviceExternalImageFormatInfo_pnext(enc, val->pNext);
8977 vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(enc, val);
8978 }
8979
8980 /* struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT chain */
8981
8982 static inline size_t
vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(const void * val)8983 vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(const void *val)
8984 {
8985 /* no known/supported struct */
8986 return vn_sizeof_simple_pointer(NULL);
8987 }
8988
8989 static inline size_t
vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)8990 vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
8991 {
8992 size_t size = 0;
8993 /* skip val->{sType,pNext} */
8994 size += vn_sizeof_uint64_t(&val->drmFormatModifier);
8995 size += vn_sizeof_VkSharingMode(&val->sharingMode);
8996 size += vn_sizeof_uint32_t(&val->queueFamilyIndexCount);
8997 if (val->pQueueFamilyIndices) {
8998 size += vn_sizeof_array_size(val->queueFamilyIndexCount);
8999 size += vn_sizeof_uint32_t_array(val->pQueueFamilyIndices, val->queueFamilyIndexCount);
9000 } else {
9001 size += vn_sizeof_array_size(0);
9002 }
9003 return size;
9004 }
9005
9006 static inline size_t
vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)9007 vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
9008 {
9009 size_t size = 0;
9010
9011 size += vn_sizeof_VkStructureType(&val->sType);
9012 size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(val->pNext);
9013 size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(val);
9014
9015 return size;
9016 }
9017
9018 static inline void
vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)9019 vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
9020 {
9021 /* no known/supported struct */
9022 vn_encode_simple_pointer(enc, NULL);
9023 }
9024
9025 static inline void
vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)9026 vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
9027 {
9028 /* skip val->{sType,pNext} */
9029 vn_encode_uint64_t(enc, &val->drmFormatModifier);
9030 vn_encode_VkSharingMode(enc, &val->sharingMode);
9031 vn_encode_uint32_t(enc, &val->queueFamilyIndexCount);
9032 if (val->pQueueFamilyIndices) {
9033 vn_encode_array_size(enc, val->queueFamilyIndexCount);
9034 vn_encode_uint32_t_array(enc, val->pQueueFamilyIndices, val->queueFamilyIndexCount);
9035 } else {
9036 vn_encode_array_size(enc, 0);
9037 }
9038 }
9039
9040 static inline void
vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)9041 vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
9042 {
9043 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT);
9044 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT });
9045 vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(enc, val->pNext);
9046 vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(enc, val);
9047 }
9048
9049 /* struct VkPhysicalDeviceImageFormatInfo2 chain */
9050
9051 static inline size_t
vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(const void * val)9052 vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(const void *val)
9053 {
9054 const VkBaseInStructure *pnext = val;
9055 size_t size = 0;
9056
9057 while (pnext) {
9058 switch ((int32_t)pnext->sType) {
9059 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
9060 size += vn_sizeof_simple_pointer(pnext);
9061 size += vn_sizeof_VkStructureType(&pnext->sType);
9062 size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
9063 size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self((const VkPhysicalDeviceExternalImageFormatInfo *)pnext);
9064 return size;
9065 case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
9066 size += vn_sizeof_simple_pointer(pnext);
9067 size += vn_sizeof_VkStructureType(&pnext->sType);
9068 size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
9069 size += vn_sizeof_VkImageFormatListCreateInfo_self((const VkImageFormatListCreateInfo *)pnext);
9070 return size;
9071 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
9072 size += vn_sizeof_simple_pointer(pnext);
9073 size += vn_sizeof_VkStructureType(&pnext->sType);
9074 size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
9075 size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self((const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)pnext);
9076 return size;
9077 case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
9078 size += vn_sizeof_simple_pointer(pnext);
9079 size += vn_sizeof_VkStructureType(&pnext->sType);
9080 size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
9081 size += vn_sizeof_VkImageStencilUsageCreateInfo_self((const VkImageStencilUsageCreateInfo *)pnext);
9082 return size;
9083 default:
9084 /* ignore unknown/unsupported struct */
9085 break;
9086 }
9087 pnext = pnext->pNext;
9088 }
9089
9090 return vn_sizeof_simple_pointer(NULL);
9091 }
9092
9093 static inline size_t
vn_sizeof_VkPhysicalDeviceImageFormatInfo2_self(const VkPhysicalDeviceImageFormatInfo2 * val)9094 vn_sizeof_VkPhysicalDeviceImageFormatInfo2_self(const VkPhysicalDeviceImageFormatInfo2 *val)
9095 {
9096 size_t size = 0;
9097 /* skip val->{sType,pNext} */
9098 size += vn_sizeof_VkFormat(&val->format);
9099 size += vn_sizeof_VkImageType(&val->type);
9100 size += vn_sizeof_VkImageTiling(&val->tiling);
9101 size += vn_sizeof_VkFlags(&val->usage);
9102 size += vn_sizeof_VkFlags(&val->flags);
9103 return size;
9104 }
9105
9106 static inline size_t
vn_sizeof_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2 * val)9107 vn_sizeof_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2 *val)
9108 {
9109 size_t size = 0;
9110
9111 size += vn_sizeof_VkStructureType(&val->sType);
9112 size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(val->pNext);
9113 size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_self(val);
9114
9115 return size;
9116 }
9117
9118 static inline void
vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(struct vn_cs_encoder * enc,const void * val)9119 vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
9120 {
9121 const VkBaseInStructure *pnext = val;
9122
9123 while (pnext) {
9124 switch ((int32_t)pnext->sType) {
9125 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
9126 vn_encode_simple_pointer(enc, pnext);
9127 vn_encode_VkStructureType(enc, &pnext->sType);
9128 vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
9129 vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(enc, (const VkPhysicalDeviceExternalImageFormatInfo *)pnext);
9130 return;
9131 case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
9132 vn_encode_simple_pointer(enc, pnext);
9133 vn_encode_VkStructureType(enc, &pnext->sType);
9134 vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
9135 vn_encode_VkImageFormatListCreateInfo_self(enc, (const VkImageFormatListCreateInfo *)pnext);
9136 return;
9137 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
9138 vn_encode_simple_pointer(enc, pnext);
9139 vn_encode_VkStructureType(enc, &pnext->sType);
9140 vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
9141 vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(enc, (const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)pnext);
9142 return;
9143 case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
9144 vn_encode_simple_pointer(enc, pnext);
9145 vn_encode_VkStructureType(enc, &pnext->sType);
9146 vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
9147 vn_encode_VkImageStencilUsageCreateInfo_self(enc, (const VkImageStencilUsageCreateInfo *)pnext);
9148 return;
9149 default:
9150 /* ignore unknown/unsupported struct */
9151 break;
9152 }
9153 pnext = pnext->pNext;
9154 }
9155
9156 vn_encode_simple_pointer(enc, NULL);
9157 }
9158
9159 static inline void
vn_encode_VkPhysicalDeviceImageFormatInfo2_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageFormatInfo2 * val)9160 vn_encode_VkPhysicalDeviceImageFormatInfo2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageFormatInfo2 *val)
9161 {
9162 /* skip val->{sType,pNext} */
9163 vn_encode_VkFormat(enc, &val->format);
9164 vn_encode_VkImageType(enc, &val->type);
9165 vn_encode_VkImageTiling(enc, &val->tiling);
9166 vn_encode_VkFlags(enc, &val->usage);
9167 vn_encode_VkFlags(enc, &val->flags);
9168 }
9169
9170 static inline void
vn_encode_VkPhysicalDeviceImageFormatInfo2(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageFormatInfo2 * val)9171 vn_encode_VkPhysicalDeviceImageFormatInfo2(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageFormatInfo2 *val)
9172 {
9173 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2);
9174 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 });
9175 vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, val->pNext);
9176 vn_encode_VkPhysicalDeviceImageFormatInfo2_self(enc, val);
9177 }
9178
9179 /* struct VkExternalMemoryProperties */
9180
9181 static inline size_t
vn_sizeof_VkExternalMemoryProperties(const VkExternalMemoryProperties * val)9182 vn_sizeof_VkExternalMemoryProperties(const VkExternalMemoryProperties *val)
9183 {
9184 size_t size = 0;
9185 size += vn_sizeof_VkFlags(&val->externalMemoryFeatures);
9186 size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes);
9187 size += vn_sizeof_VkFlags(&val->compatibleHandleTypes);
9188 return size;
9189 }
9190
9191 static inline void
vn_decode_VkExternalMemoryProperties(struct vn_cs_decoder * dec,VkExternalMemoryProperties * val)9192 vn_decode_VkExternalMemoryProperties(struct vn_cs_decoder *dec, VkExternalMemoryProperties *val)
9193 {
9194 vn_decode_VkFlags(dec, &val->externalMemoryFeatures);
9195 vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes);
9196 vn_decode_VkFlags(dec, &val->compatibleHandleTypes);
9197 }
9198
9199 static inline size_t
vn_sizeof_VkExternalMemoryProperties_partial(const VkExternalMemoryProperties * val)9200 vn_sizeof_VkExternalMemoryProperties_partial(const VkExternalMemoryProperties *val)
9201 {
9202 size_t size = 0;
9203 /* skip val->externalMemoryFeatures */
9204 /* skip val->exportFromImportedHandleTypes */
9205 /* skip val->compatibleHandleTypes */
9206 return size;
9207 }
9208
9209 static inline void
vn_encode_VkExternalMemoryProperties_partial(struct vn_cs_encoder * enc,const VkExternalMemoryProperties * val)9210 vn_encode_VkExternalMemoryProperties_partial(struct vn_cs_encoder *enc, const VkExternalMemoryProperties *val)
9211 {
9212 /* skip val->externalMemoryFeatures */
9213 /* skip val->exportFromImportedHandleTypes */
9214 /* skip val->compatibleHandleTypes */
9215 }
9216
9217 /* struct VkExternalImageFormatProperties chain */
9218
9219 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_pnext(const void * val)9220 vn_sizeof_VkExternalImageFormatProperties_pnext(const void *val)
9221 {
9222 /* no known/supported struct */
9223 return vn_sizeof_simple_pointer(NULL);
9224 }
9225
9226 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_self(const VkExternalImageFormatProperties * val)9227 vn_sizeof_VkExternalImageFormatProperties_self(const VkExternalImageFormatProperties *val)
9228 {
9229 size_t size = 0;
9230 /* skip val->{sType,pNext} */
9231 size += vn_sizeof_VkExternalMemoryProperties(&val->externalMemoryProperties);
9232 return size;
9233 }
9234
9235 static inline size_t
vn_sizeof_VkExternalImageFormatProperties(const VkExternalImageFormatProperties * val)9236 vn_sizeof_VkExternalImageFormatProperties(const VkExternalImageFormatProperties *val)
9237 {
9238 size_t size = 0;
9239
9240 size += vn_sizeof_VkStructureType(&val->sType);
9241 size += vn_sizeof_VkExternalImageFormatProperties_pnext(val->pNext);
9242 size += vn_sizeof_VkExternalImageFormatProperties_self(val);
9243
9244 return size;
9245 }
9246
9247 static inline void
vn_decode_VkExternalImageFormatProperties_pnext(struct vn_cs_decoder * dec,const void * val)9248 vn_decode_VkExternalImageFormatProperties_pnext(struct vn_cs_decoder *dec, const void *val)
9249 {
9250 /* no known/supported struct */
9251 if (vn_decode_simple_pointer(dec))
9252 assert(false);
9253 }
9254
9255 static inline void
vn_decode_VkExternalImageFormatProperties_self(struct vn_cs_decoder * dec,VkExternalImageFormatProperties * val)9256 vn_decode_VkExternalImageFormatProperties_self(struct vn_cs_decoder *dec, VkExternalImageFormatProperties *val)
9257 {
9258 /* skip val->{sType,pNext} */
9259 vn_decode_VkExternalMemoryProperties(dec, &val->externalMemoryProperties);
9260 }
9261
9262 static inline void
vn_decode_VkExternalImageFormatProperties(struct vn_cs_decoder * dec,VkExternalImageFormatProperties * val)9263 vn_decode_VkExternalImageFormatProperties(struct vn_cs_decoder *dec, VkExternalImageFormatProperties *val)
9264 {
9265 VkStructureType stype;
9266 vn_decode_VkStructureType(dec, &stype);
9267 assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
9268
9269 assert(val->sType == stype);
9270 vn_decode_VkExternalImageFormatProperties_pnext(dec, val->pNext);
9271 vn_decode_VkExternalImageFormatProperties_self(dec, val);
9272 }
9273
9274 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_pnext_partial(const void * val)9275 vn_sizeof_VkExternalImageFormatProperties_pnext_partial(const void *val)
9276 {
9277 /* no known/supported struct */
9278 return vn_sizeof_simple_pointer(NULL);
9279 }
9280
9281 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_self_partial(const VkExternalImageFormatProperties * val)9282 vn_sizeof_VkExternalImageFormatProperties_self_partial(const VkExternalImageFormatProperties *val)
9283 {
9284 size_t size = 0;
9285 /* skip val->{sType,pNext} */
9286 size += vn_sizeof_VkExternalMemoryProperties_partial(&val->externalMemoryProperties);
9287 return size;
9288 }
9289
9290 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_partial(const VkExternalImageFormatProperties * val)9291 vn_sizeof_VkExternalImageFormatProperties_partial(const VkExternalImageFormatProperties *val)
9292 {
9293 size_t size = 0;
9294
9295 size += vn_sizeof_VkStructureType(&val->sType);
9296 size += vn_sizeof_VkExternalImageFormatProperties_pnext_partial(val->pNext);
9297 size += vn_sizeof_VkExternalImageFormatProperties_self_partial(val);
9298
9299 return size;
9300 }
9301
9302 static inline void
vn_encode_VkExternalImageFormatProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)9303 vn_encode_VkExternalImageFormatProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9304 {
9305 /* no known/supported struct */
9306 vn_encode_simple_pointer(enc, NULL);
9307 }
9308
9309 static inline void
vn_encode_VkExternalImageFormatProperties_self_partial(struct vn_cs_encoder * enc,const VkExternalImageFormatProperties * val)9310 vn_encode_VkExternalImageFormatProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalImageFormatProperties *val)
9311 {
9312 /* skip val->{sType,pNext} */
9313 vn_encode_VkExternalMemoryProperties_partial(enc, &val->externalMemoryProperties);
9314 }
9315
9316 static inline void
vn_encode_VkExternalImageFormatProperties_partial(struct vn_cs_encoder * enc,const VkExternalImageFormatProperties * val)9317 vn_encode_VkExternalImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkExternalImageFormatProperties *val)
9318 {
9319 assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
9320 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES });
9321 vn_encode_VkExternalImageFormatProperties_pnext_partial(enc, val->pNext);
9322 vn_encode_VkExternalImageFormatProperties_self_partial(enc, val);
9323 }
9324
9325 /* struct VkSamplerYcbcrConversionImageFormatProperties chain */
9326
9327 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext(const void * val)9328 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext(const void *val)
9329 {
9330 /* no known/supported struct */
9331 return vn_sizeof_simple_pointer(NULL);
9332 }
9333
9334 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self(const VkSamplerYcbcrConversionImageFormatProperties * val)9335 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self(const VkSamplerYcbcrConversionImageFormatProperties *val)
9336 {
9337 size_t size = 0;
9338 /* skip val->{sType,pNext} */
9339 size += vn_sizeof_uint32_t(&val->combinedImageSamplerDescriptorCount);
9340 return size;
9341 }
9342
9343 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties * val)9344 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties *val)
9345 {
9346 size_t size = 0;
9347
9348 size += vn_sizeof_VkStructureType(&val->sType);
9349 size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext(val->pNext);
9350 size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self(val);
9351
9352 return size;
9353 }
9354
9355 static inline void
vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext(struct vn_cs_decoder * dec,const void * val)9356 vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext(struct vn_cs_decoder *dec, const void *val)
9357 {
9358 /* no known/supported struct */
9359 if (vn_decode_simple_pointer(dec))
9360 assert(false);
9361 }
9362
9363 static inline void
vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(struct vn_cs_decoder * dec,VkSamplerYcbcrConversionImageFormatProperties * val)9364 vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(struct vn_cs_decoder *dec, VkSamplerYcbcrConversionImageFormatProperties *val)
9365 {
9366 /* skip val->{sType,pNext} */
9367 vn_decode_uint32_t(dec, &val->combinedImageSamplerDescriptorCount);
9368 }
9369
9370 static inline void
vn_decode_VkSamplerYcbcrConversionImageFormatProperties(struct vn_cs_decoder * dec,VkSamplerYcbcrConversionImageFormatProperties * val)9371 vn_decode_VkSamplerYcbcrConversionImageFormatProperties(struct vn_cs_decoder *dec, VkSamplerYcbcrConversionImageFormatProperties *val)
9372 {
9373 VkStructureType stype;
9374 vn_decode_VkStructureType(dec, &stype);
9375 assert(stype == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
9376
9377 assert(val->sType == stype);
9378 vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext(dec, val->pNext);
9379 vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(dec, val);
9380 }
9381
9382 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(const void * val)9383 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(const void *val)
9384 {
9385 /* no known/supported struct */
9386 return vn_sizeof_simple_pointer(NULL);
9387 }
9388
9389 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial(const VkSamplerYcbcrConversionImageFormatProperties * val)9390 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial(const VkSamplerYcbcrConversionImageFormatProperties *val)
9391 {
9392 size_t size = 0;
9393 /* skip val->{sType,pNext} */
9394 /* skip val->combinedImageSamplerDescriptorCount */
9395 return size;
9396 }
9397
9398 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_partial(const VkSamplerYcbcrConversionImageFormatProperties * val)9399 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_partial(const VkSamplerYcbcrConversionImageFormatProperties *val)
9400 {
9401 size_t size = 0;
9402
9403 size += vn_sizeof_VkStructureType(&val->sType);
9404 size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(val->pNext);
9405 size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial(val);
9406
9407 return size;
9408 }
9409
9410 static inline void
vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)9411 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9412 {
9413 /* no known/supported struct */
9414 vn_encode_simple_pointer(enc, NULL);
9415 }
9416
9417 static inline void
vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(struct vn_cs_encoder * enc,const VkSamplerYcbcrConversionImageFormatProperties * val)9418 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionImageFormatProperties *val)
9419 {
9420 /* skip val->{sType,pNext} */
9421 /* skip val->combinedImageSamplerDescriptorCount */
9422 }
9423
9424 static inline void
vn_encode_VkSamplerYcbcrConversionImageFormatProperties_partial(struct vn_cs_encoder * enc,const VkSamplerYcbcrConversionImageFormatProperties * val)9425 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionImageFormatProperties *val)
9426 {
9427 assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
9428 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES });
9429 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(enc, val->pNext);
9430 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(enc, val);
9431 }
9432
9433 /* struct VkImageFormatProperties2 chain */
9434
9435 static inline size_t
vn_sizeof_VkImageFormatProperties2_pnext(const void * val)9436 vn_sizeof_VkImageFormatProperties2_pnext(const void *val)
9437 {
9438 const VkBaseInStructure *pnext = val;
9439 size_t size = 0;
9440
9441 while (pnext) {
9442 switch ((int32_t)pnext->sType) {
9443 case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
9444 size += vn_sizeof_simple_pointer(pnext);
9445 size += vn_sizeof_VkStructureType(&pnext->sType);
9446 size += vn_sizeof_VkImageFormatProperties2_pnext(pnext->pNext);
9447 size += vn_sizeof_VkExternalImageFormatProperties_self((const VkExternalImageFormatProperties *)pnext);
9448 return size;
9449 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
9450 size += vn_sizeof_simple_pointer(pnext);
9451 size += vn_sizeof_VkStructureType(&pnext->sType);
9452 size += vn_sizeof_VkImageFormatProperties2_pnext(pnext->pNext);
9453 size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self((const VkSamplerYcbcrConversionImageFormatProperties *)pnext);
9454 return size;
9455 default:
9456 /* ignore unknown/unsupported struct */
9457 break;
9458 }
9459 pnext = pnext->pNext;
9460 }
9461
9462 return vn_sizeof_simple_pointer(NULL);
9463 }
9464
9465 static inline size_t
vn_sizeof_VkImageFormatProperties2_self(const VkImageFormatProperties2 * val)9466 vn_sizeof_VkImageFormatProperties2_self(const VkImageFormatProperties2 *val)
9467 {
9468 size_t size = 0;
9469 /* skip val->{sType,pNext} */
9470 size += vn_sizeof_VkImageFormatProperties(&val->imageFormatProperties);
9471 return size;
9472 }
9473
9474 static inline size_t
vn_sizeof_VkImageFormatProperties2(const VkImageFormatProperties2 * val)9475 vn_sizeof_VkImageFormatProperties2(const VkImageFormatProperties2 *val)
9476 {
9477 size_t size = 0;
9478
9479 size += vn_sizeof_VkStructureType(&val->sType);
9480 size += vn_sizeof_VkImageFormatProperties2_pnext(val->pNext);
9481 size += vn_sizeof_VkImageFormatProperties2_self(val);
9482
9483 return size;
9484 }
9485
9486 static inline void
vn_decode_VkImageFormatProperties2_pnext(struct vn_cs_decoder * dec,const void * val)9487 vn_decode_VkImageFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
9488 {
9489 VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
9490 VkStructureType stype;
9491
9492 if (!vn_decode_simple_pointer(dec))
9493 return;
9494
9495 vn_decode_VkStructureType(dec, &stype);
9496 while (true) {
9497 assert(pnext);
9498 if (pnext->sType == stype)
9499 break;
9500 }
9501
9502 switch ((int32_t)pnext->sType) {
9503 case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
9504 vn_decode_VkImageFormatProperties2_pnext(dec, pnext->pNext);
9505 vn_decode_VkExternalImageFormatProperties_self(dec, (VkExternalImageFormatProperties *)pnext);
9506 break;
9507 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
9508 vn_decode_VkImageFormatProperties2_pnext(dec, pnext->pNext);
9509 vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(dec, (VkSamplerYcbcrConversionImageFormatProperties *)pnext);
9510 break;
9511 default:
9512 assert(false);
9513 break;
9514 }
9515 }
9516
9517 static inline void
vn_decode_VkImageFormatProperties2_self(struct vn_cs_decoder * dec,VkImageFormatProperties2 * val)9518 vn_decode_VkImageFormatProperties2_self(struct vn_cs_decoder *dec, VkImageFormatProperties2 *val)
9519 {
9520 /* skip val->{sType,pNext} */
9521 vn_decode_VkImageFormatProperties(dec, &val->imageFormatProperties);
9522 }
9523
9524 static inline void
vn_decode_VkImageFormatProperties2(struct vn_cs_decoder * dec,VkImageFormatProperties2 * val)9525 vn_decode_VkImageFormatProperties2(struct vn_cs_decoder *dec, VkImageFormatProperties2 *val)
9526 {
9527 VkStructureType stype;
9528 vn_decode_VkStructureType(dec, &stype);
9529 assert(stype == VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2);
9530
9531 assert(val->sType == stype);
9532 vn_decode_VkImageFormatProperties2_pnext(dec, val->pNext);
9533 vn_decode_VkImageFormatProperties2_self(dec, val);
9534 }
9535
9536 static inline size_t
vn_sizeof_VkImageFormatProperties2_pnext_partial(const void * val)9537 vn_sizeof_VkImageFormatProperties2_pnext_partial(const void *val)
9538 {
9539 const VkBaseInStructure *pnext = val;
9540 size_t size = 0;
9541
9542 while (pnext) {
9543 switch ((int32_t)pnext->sType) {
9544 case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
9545 size += vn_sizeof_simple_pointer(pnext);
9546 size += vn_sizeof_VkStructureType(&pnext->sType);
9547 size += vn_sizeof_VkImageFormatProperties2_pnext_partial(pnext->pNext);
9548 size += vn_sizeof_VkExternalImageFormatProperties_self_partial((const VkExternalImageFormatProperties *)pnext);
9549 return size;
9550 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
9551 size += vn_sizeof_simple_pointer(pnext);
9552 size += vn_sizeof_VkStructureType(&pnext->sType);
9553 size += vn_sizeof_VkImageFormatProperties2_pnext_partial(pnext->pNext);
9554 size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial((const VkSamplerYcbcrConversionImageFormatProperties *)pnext);
9555 return size;
9556 default:
9557 /* ignore unknown/unsupported struct */
9558 break;
9559 }
9560 pnext = pnext->pNext;
9561 }
9562
9563 return vn_sizeof_simple_pointer(NULL);
9564 }
9565
9566 static inline size_t
vn_sizeof_VkImageFormatProperties2_self_partial(const VkImageFormatProperties2 * val)9567 vn_sizeof_VkImageFormatProperties2_self_partial(const VkImageFormatProperties2 *val)
9568 {
9569 size_t size = 0;
9570 /* skip val->{sType,pNext} */
9571 size += vn_sizeof_VkImageFormatProperties_partial(&val->imageFormatProperties);
9572 return size;
9573 }
9574
9575 static inline size_t
vn_sizeof_VkImageFormatProperties2_partial(const VkImageFormatProperties2 * val)9576 vn_sizeof_VkImageFormatProperties2_partial(const VkImageFormatProperties2 *val)
9577 {
9578 size_t size = 0;
9579
9580 size += vn_sizeof_VkStructureType(&val->sType);
9581 size += vn_sizeof_VkImageFormatProperties2_pnext_partial(val->pNext);
9582 size += vn_sizeof_VkImageFormatProperties2_self_partial(val);
9583
9584 return size;
9585 }
9586
9587 static inline void
vn_encode_VkImageFormatProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)9588 vn_encode_VkImageFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9589 {
9590 const VkBaseInStructure *pnext = val;
9591
9592 while (pnext) {
9593 switch ((int32_t)pnext->sType) {
9594 case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
9595 vn_encode_simple_pointer(enc, pnext);
9596 vn_encode_VkStructureType(enc, &pnext->sType);
9597 vn_encode_VkImageFormatProperties2_pnext_partial(enc, pnext->pNext);
9598 vn_encode_VkExternalImageFormatProperties_self_partial(enc, (const VkExternalImageFormatProperties *)pnext);
9599 return;
9600 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
9601 vn_encode_simple_pointer(enc, pnext);
9602 vn_encode_VkStructureType(enc, &pnext->sType);
9603 vn_encode_VkImageFormatProperties2_pnext_partial(enc, pnext->pNext);
9604 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(enc, (const VkSamplerYcbcrConversionImageFormatProperties *)pnext);
9605 return;
9606 default:
9607 /* ignore unknown/unsupported struct */
9608 break;
9609 }
9610 pnext = pnext->pNext;
9611 }
9612
9613 vn_encode_simple_pointer(enc, NULL);
9614 }
9615
9616 static inline void
vn_encode_VkImageFormatProperties2_self_partial(struct vn_cs_encoder * enc,const VkImageFormatProperties2 * val)9617 vn_encode_VkImageFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkImageFormatProperties2 *val)
9618 {
9619 /* skip val->{sType,pNext} */
9620 vn_encode_VkImageFormatProperties_partial(enc, &val->imageFormatProperties);
9621 }
9622
9623 static inline void
vn_encode_VkImageFormatProperties2_partial(struct vn_cs_encoder * enc,const VkImageFormatProperties2 * val)9624 vn_encode_VkImageFormatProperties2_partial(struct vn_cs_encoder *enc, const VkImageFormatProperties2 *val)
9625 {
9626 assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2);
9627 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 });
9628 vn_encode_VkImageFormatProperties2_pnext_partial(enc, val->pNext);
9629 vn_encode_VkImageFormatProperties2_self_partial(enc, val);
9630 }
9631
9632 /* struct VkQueueFamilyProperties2 chain */
9633
9634 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_pnext(const void * val)9635 vn_sizeof_VkQueueFamilyProperties2_pnext(const void *val)
9636 {
9637 /* no known/supported struct */
9638 return vn_sizeof_simple_pointer(NULL);
9639 }
9640
9641 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_self(const VkQueueFamilyProperties2 * val)9642 vn_sizeof_VkQueueFamilyProperties2_self(const VkQueueFamilyProperties2 *val)
9643 {
9644 size_t size = 0;
9645 /* skip val->{sType,pNext} */
9646 size += vn_sizeof_VkQueueFamilyProperties(&val->queueFamilyProperties);
9647 return size;
9648 }
9649
9650 static inline size_t
vn_sizeof_VkQueueFamilyProperties2(const VkQueueFamilyProperties2 * val)9651 vn_sizeof_VkQueueFamilyProperties2(const VkQueueFamilyProperties2 *val)
9652 {
9653 size_t size = 0;
9654
9655 size += vn_sizeof_VkStructureType(&val->sType);
9656 size += vn_sizeof_VkQueueFamilyProperties2_pnext(val->pNext);
9657 size += vn_sizeof_VkQueueFamilyProperties2_self(val);
9658
9659 return size;
9660 }
9661
9662 static inline void
vn_decode_VkQueueFamilyProperties2_pnext(struct vn_cs_decoder * dec,const void * val)9663 vn_decode_VkQueueFamilyProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
9664 {
9665 /* no known/supported struct */
9666 if (vn_decode_simple_pointer(dec))
9667 assert(false);
9668 }
9669
9670 static inline void
vn_decode_VkQueueFamilyProperties2_self(struct vn_cs_decoder * dec,VkQueueFamilyProperties2 * val)9671 vn_decode_VkQueueFamilyProperties2_self(struct vn_cs_decoder *dec, VkQueueFamilyProperties2 *val)
9672 {
9673 /* skip val->{sType,pNext} */
9674 vn_decode_VkQueueFamilyProperties(dec, &val->queueFamilyProperties);
9675 }
9676
9677 static inline void
vn_decode_VkQueueFamilyProperties2(struct vn_cs_decoder * dec,VkQueueFamilyProperties2 * val)9678 vn_decode_VkQueueFamilyProperties2(struct vn_cs_decoder *dec, VkQueueFamilyProperties2 *val)
9679 {
9680 VkStructureType stype;
9681 vn_decode_VkStructureType(dec, &stype);
9682 assert(stype == VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2);
9683
9684 assert(val->sType == stype);
9685 vn_decode_VkQueueFamilyProperties2_pnext(dec, val->pNext);
9686 vn_decode_VkQueueFamilyProperties2_self(dec, val);
9687 }
9688
9689 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_pnext_partial(const void * val)9690 vn_sizeof_VkQueueFamilyProperties2_pnext_partial(const void *val)
9691 {
9692 /* no known/supported struct */
9693 return vn_sizeof_simple_pointer(NULL);
9694 }
9695
9696 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_self_partial(const VkQueueFamilyProperties2 * val)9697 vn_sizeof_VkQueueFamilyProperties2_self_partial(const VkQueueFamilyProperties2 *val)
9698 {
9699 size_t size = 0;
9700 /* skip val->{sType,pNext} */
9701 size += vn_sizeof_VkQueueFamilyProperties_partial(&val->queueFamilyProperties);
9702 return size;
9703 }
9704
9705 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_partial(const VkQueueFamilyProperties2 * val)9706 vn_sizeof_VkQueueFamilyProperties2_partial(const VkQueueFamilyProperties2 *val)
9707 {
9708 size_t size = 0;
9709
9710 size += vn_sizeof_VkStructureType(&val->sType);
9711 size += vn_sizeof_VkQueueFamilyProperties2_pnext_partial(val->pNext);
9712 size += vn_sizeof_VkQueueFamilyProperties2_self_partial(val);
9713
9714 return size;
9715 }
9716
9717 static inline void
vn_encode_VkQueueFamilyProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)9718 vn_encode_VkQueueFamilyProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9719 {
9720 /* no known/supported struct */
9721 vn_encode_simple_pointer(enc, NULL);
9722 }
9723
9724 static inline void
vn_encode_VkQueueFamilyProperties2_self_partial(struct vn_cs_encoder * enc,const VkQueueFamilyProperties2 * val)9725 vn_encode_VkQueueFamilyProperties2_self_partial(struct vn_cs_encoder *enc, const VkQueueFamilyProperties2 *val)
9726 {
9727 /* skip val->{sType,pNext} */
9728 vn_encode_VkQueueFamilyProperties_partial(enc, &val->queueFamilyProperties);
9729 }
9730
9731 static inline void
vn_encode_VkQueueFamilyProperties2_partial(struct vn_cs_encoder * enc,const VkQueueFamilyProperties2 * val)9732 vn_encode_VkQueueFamilyProperties2_partial(struct vn_cs_encoder *enc, const VkQueueFamilyProperties2 *val)
9733 {
9734 assert(val->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2);
9735 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 });
9736 vn_encode_VkQueueFamilyProperties2_pnext_partial(enc, val->pNext);
9737 vn_encode_VkQueueFamilyProperties2_self_partial(enc, val);
9738 }
9739
9740 /* struct VkPhysicalDeviceMemoryProperties2 chain */
9741
9742 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext(const void * val)9743 vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext(const void *val)
9744 {
9745 /* no known/supported struct */
9746 return vn_sizeof_simple_pointer(NULL);
9747 }
9748
9749 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_self(const VkPhysicalDeviceMemoryProperties2 * val)9750 vn_sizeof_VkPhysicalDeviceMemoryProperties2_self(const VkPhysicalDeviceMemoryProperties2 *val)
9751 {
9752 size_t size = 0;
9753 /* skip val->{sType,pNext} */
9754 size += vn_sizeof_VkPhysicalDeviceMemoryProperties(&val->memoryProperties);
9755 return size;
9756 }
9757
9758 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2 * val)9759 vn_sizeof_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2 *val)
9760 {
9761 size_t size = 0;
9762
9763 size += vn_sizeof_VkStructureType(&val->sType);
9764 size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext(val->pNext);
9765 size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_self(val);
9766
9767 return size;
9768 }
9769
9770 static inline void
vn_decode_VkPhysicalDeviceMemoryProperties2_pnext(struct vn_cs_decoder * dec,const void * val)9771 vn_decode_VkPhysicalDeviceMemoryProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
9772 {
9773 /* no known/supported struct */
9774 if (vn_decode_simple_pointer(dec))
9775 assert(false);
9776 }
9777
9778 static inline void
vn_decode_VkPhysicalDeviceMemoryProperties2_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMemoryProperties2 * val)9779 vn_decode_VkPhysicalDeviceMemoryProperties2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties2 *val)
9780 {
9781 /* skip val->{sType,pNext} */
9782 vn_decode_VkPhysicalDeviceMemoryProperties(dec, &val->memoryProperties);
9783 }
9784
9785 static inline void
vn_decode_VkPhysicalDeviceMemoryProperties2(struct vn_cs_decoder * dec,VkPhysicalDeviceMemoryProperties2 * val)9786 vn_decode_VkPhysicalDeviceMemoryProperties2(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties2 *val)
9787 {
9788 VkStructureType stype;
9789 vn_decode_VkStructureType(dec, &stype);
9790 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2);
9791
9792 assert(val->sType == stype);
9793 vn_decode_VkPhysicalDeviceMemoryProperties2_pnext(dec, val->pNext);
9794 vn_decode_VkPhysicalDeviceMemoryProperties2_self(dec, val);
9795 }
9796
9797 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext_partial(const void * val)9798 vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext_partial(const void *val)
9799 {
9800 /* no known/supported struct */
9801 return vn_sizeof_simple_pointer(NULL);
9802 }
9803
9804 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_self_partial(const VkPhysicalDeviceMemoryProperties2 * val)9805 vn_sizeof_VkPhysicalDeviceMemoryProperties2_self_partial(const VkPhysicalDeviceMemoryProperties2 *val)
9806 {
9807 size_t size = 0;
9808 /* skip val->{sType,pNext} */
9809 size += vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(&val->memoryProperties);
9810 return size;
9811 }
9812
9813 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_partial(const VkPhysicalDeviceMemoryProperties2 * val)9814 vn_sizeof_VkPhysicalDeviceMemoryProperties2_partial(const VkPhysicalDeviceMemoryProperties2 *val)
9815 {
9816 size_t size = 0;
9817
9818 size += vn_sizeof_VkStructureType(&val->sType);
9819 size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext_partial(val->pNext);
9820 size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_self_partial(val);
9821
9822 return size;
9823 }
9824
9825 static inline void
vn_encode_VkPhysicalDeviceMemoryProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)9826 vn_encode_VkPhysicalDeviceMemoryProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9827 {
9828 /* no known/supported struct */
9829 vn_encode_simple_pointer(enc, NULL);
9830 }
9831
9832 static inline void
vn_encode_VkPhysicalDeviceMemoryProperties2_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMemoryProperties2 * val)9833 vn_encode_VkPhysicalDeviceMemoryProperties2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties2 *val)
9834 {
9835 /* skip val->{sType,pNext} */
9836 vn_encode_VkPhysicalDeviceMemoryProperties_partial(enc, &val->memoryProperties);
9837 }
9838
9839 static inline void
vn_encode_VkPhysicalDeviceMemoryProperties2_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMemoryProperties2 * val)9840 vn_encode_VkPhysicalDeviceMemoryProperties2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties2 *val)
9841 {
9842 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2);
9843 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 });
9844 vn_encode_VkPhysicalDeviceMemoryProperties2_pnext_partial(enc, val->pNext);
9845 vn_encode_VkPhysicalDeviceMemoryProperties2_self_partial(enc, val);
9846 }
9847
9848 /* struct VkPhysicalDeviceSparseImageFormatInfo2 chain */
9849
9850 static inline size_t
vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_pnext(const void * val)9851 vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_pnext(const void *val)
9852 {
9853 /* no known/supported struct */
9854 return vn_sizeof_simple_pointer(NULL);
9855 }
9856
9857 static inline size_t
vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_self(const VkPhysicalDeviceSparseImageFormatInfo2 * val)9858 vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_self(const VkPhysicalDeviceSparseImageFormatInfo2 *val)
9859 {
9860 size_t size = 0;
9861 /* skip val->{sType,pNext} */
9862 size += vn_sizeof_VkFormat(&val->format);
9863 size += vn_sizeof_VkImageType(&val->type);
9864 size += vn_sizeof_VkSampleCountFlagBits(&val->samples);
9865 size += vn_sizeof_VkFlags(&val->usage);
9866 size += vn_sizeof_VkImageTiling(&val->tiling);
9867 return size;
9868 }
9869
9870 static inline size_t
vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2 * val)9871 vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2 *val)
9872 {
9873 size_t size = 0;
9874
9875 size += vn_sizeof_VkStructureType(&val->sType);
9876 size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_pnext(val->pNext);
9877 size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_self(val);
9878
9879 return size;
9880 }
9881
9882 static inline void
vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_pnext(struct vn_cs_encoder * enc,const void * val)9883 vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
9884 {
9885 /* no known/supported struct */
9886 vn_encode_simple_pointer(enc, NULL);
9887 }
9888
9889 static inline void
vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceSparseImageFormatInfo2 * val)9890 vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseImageFormatInfo2 *val)
9891 {
9892 /* skip val->{sType,pNext} */
9893 vn_encode_VkFormat(enc, &val->format);
9894 vn_encode_VkImageType(enc, &val->type);
9895 vn_encode_VkSampleCountFlagBits(enc, &val->samples);
9896 vn_encode_VkFlags(enc, &val->usage);
9897 vn_encode_VkImageTiling(enc, &val->tiling);
9898 }
9899
9900 static inline void
vn_encode_VkPhysicalDeviceSparseImageFormatInfo2(struct vn_cs_encoder * enc,const VkPhysicalDeviceSparseImageFormatInfo2 * val)9901 vn_encode_VkPhysicalDeviceSparseImageFormatInfo2(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseImageFormatInfo2 *val)
9902 {
9903 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2);
9904 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 });
9905 vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_pnext(enc, val->pNext);
9906 vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_self(enc, val);
9907 }
9908
9909 /* struct VkSparseImageFormatProperties2 chain */
9910
9911 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_pnext(const void * val)9912 vn_sizeof_VkSparseImageFormatProperties2_pnext(const void *val)
9913 {
9914 /* no known/supported struct */
9915 return vn_sizeof_simple_pointer(NULL);
9916 }
9917
9918 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_self(const VkSparseImageFormatProperties2 * val)9919 vn_sizeof_VkSparseImageFormatProperties2_self(const VkSparseImageFormatProperties2 *val)
9920 {
9921 size_t size = 0;
9922 /* skip val->{sType,pNext} */
9923 size += vn_sizeof_VkSparseImageFormatProperties(&val->properties);
9924 return size;
9925 }
9926
9927 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2 * val)9928 vn_sizeof_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2 *val)
9929 {
9930 size_t size = 0;
9931
9932 size += vn_sizeof_VkStructureType(&val->sType);
9933 size += vn_sizeof_VkSparseImageFormatProperties2_pnext(val->pNext);
9934 size += vn_sizeof_VkSparseImageFormatProperties2_self(val);
9935
9936 return size;
9937 }
9938
9939 static inline void
vn_decode_VkSparseImageFormatProperties2_pnext(struct vn_cs_decoder * dec,const void * val)9940 vn_decode_VkSparseImageFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
9941 {
9942 /* no known/supported struct */
9943 if (vn_decode_simple_pointer(dec))
9944 assert(false);
9945 }
9946
9947 static inline void
vn_decode_VkSparseImageFormatProperties2_self(struct vn_cs_decoder * dec,VkSparseImageFormatProperties2 * val)9948 vn_decode_VkSparseImageFormatProperties2_self(struct vn_cs_decoder *dec, VkSparseImageFormatProperties2 *val)
9949 {
9950 /* skip val->{sType,pNext} */
9951 vn_decode_VkSparseImageFormatProperties(dec, &val->properties);
9952 }
9953
9954 static inline void
vn_decode_VkSparseImageFormatProperties2(struct vn_cs_decoder * dec,VkSparseImageFormatProperties2 * val)9955 vn_decode_VkSparseImageFormatProperties2(struct vn_cs_decoder *dec, VkSparseImageFormatProperties2 *val)
9956 {
9957 VkStructureType stype;
9958 vn_decode_VkStructureType(dec, &stype);
9959 assert(stype == VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2);
9960
9961 assert(val->sType == stype);
9962 vn_decode_VkSparseImageFormatProperties2_pnext(dec, val->pNext);
9963 vn_decode_VkSparseImageFormatProperties2_self(dec, val);
9964 }
9965
9966 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_pnext_partial(const void * val)9967 vn_sizeof_VkSparseImageFormatProperties2_pnext_partial(const void *val)
9968 {
9969 /* no known/supported struct */
9970 return vn_sizeof_simple_pointer(NULL);
9971 }
9972
9973 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_self_partial(const VkSparseImageFormatProperties2 * val)9974 vn_sizeof_VkSparseImageFormatProperties2_self_partial(const VkSparseImageFormatProperties2 *val)
9975 {
9976 size_t size = 0;
9977 /* skip val->{sType,pNext} */
9978 size += vn_sizeof_VkSparseImageFormatProperties_partial(&val->properties);
9979 return size;
9980 }
9981
9982 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_partial(const VkSparseImageFormatProperties2 * val)9983 vn_sizeof_VkSparseImageFormatProperties2_partial(const VkSparseImageFormatProperties2 *val)
9984 {
9985 size_t size = 0;
9986
9987 size += vn_sizeof_VkStructureType(&val->sType);
9988 size += vn_sizeof_VkSparseImageFormatProperties2_pnext_partial(val->pNext);
9989 size += vn_sizeof_VkSparseImageFormatProperties2_self_partial(val);
9990
9991 return size;
9992 }
9993
9994 static inline void
vn_encode_VkSparseImageFormatProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)9995 vn_encode_VkSparseImageFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9996 {
9997 /* no known/supported struct */
9998 vn_encode_simple_pointer(enc, NULL);
9999 }
10000
10001 static inline void
vn_encode_VkSparseImageFormatProperties2_self_partial(struct vn_cs_encoder * enc,const VkSparseImageFormatProperties2 * val)10002 vn_encode_VkSparseImageFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties2 *val)
10003 {
10004 /* skip val->{sType,pNext} */
10005 vn_encode_VkSparseImageFormatProperties_partial(enc, &val->properties);
10006 }
10007
10008 static inline void
vn_encode_VkSparseImageFormatProperties2_partial(struct vn_cs_encoder * enc,const VkSparseImageFormatProperties2 * val)10009 vn_encode_VkSparseImageFormatProperties2_partial(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties2 *val)
10010 {
10011 assert(val->sType == VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2);
10012 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 });
10013 vn_encode_VkSparseImageFormatProperties2_pnext_partial(enc, val->pNext);
10014 vn_encode_VkSparseImageFormatProperties2_self_partial(enc, val);
10015 }
10016
10017 /* struct VkPhysicalDeviceExternalBufferInfo chain */
10018
10019 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(const void * val)10020 vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(const void *val)
10021 {
10022 /* no known/supported struct */
10023 return vn_sizeof_simple_pointer(NULL);
10024 }
10025
10026 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalBufferInfo_self(const VkPhysicalDeviceExternalBufferInfo * val)10027 vn_sizeof_VkPhysicalDeviceExternalBufferInfo_self(const VkPhysicalDeviceExternalBufferInfo *val)
10028 {
10029 size_t size = 0;
10030 /* skip val->{sType,pNext} */
10031 size += vn_sizeof_VkFlags(&val->flags);
10032 size += vn_sizeof_VkFlags(&val->usage);
10033 size += vn_sizeof_VkExternalMemoryHandleTypeFlagBits(&val->handleType);
10034 return size;
10035 }
10036
10037 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo * val)10038 vn_sizeof_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo *val)
10039 {
10040 size_t size = 0;
10041
10042 size += vn_sizeof_VkStructureType(&val->sType);
10043 size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(val->pNext);
10044 size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo_self(val);
10045
10046 return size;
10047 }
10048
10049 static inline void
vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(struct vn_cs_encoder * enc,const void * val)10050 vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(struct vn_cs_encoder *enc, const void *val)
10051 {
10052 /* no known/supported struct */
10053 vn_encode_simple_pointer(enc, NULL);
10054 }
10055
10056 static inline void
vn_encode_VkPhysicalDeviceExternalBufferInfo_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalBufferInfo * val)10057 vn_encode_VkPhysicalDeviceExternalBufferInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalBufferInfo *val)
10058 {
10059 /* skip val->{sType,pNext} */
10060 vn_encode_VkFlags(enc, &val->flags);
10061 vn_encode_VkFlags(enc, &val->usage);
10062 vn_encode_VkExternalMemoryHandleTypeFlagBits(enc, &val->handleType);
10063 }
10064
10065 static inline void
vn_encode_VkPhysicalDeviceExternalBufferInfo(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalBufferInfo * val)10066 vn_encode_VkPhysicalDeviceExternalBufferInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalBufferInfo *val)
10067 {
10068 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO);
10069 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO });
10070 vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(enc, val->pNext);
10071 vn_encode_VkPhysicalDeviceExternalBufferInfo_self(enc, val);
10072 }
10073
10074 /* struct VkExternalBufferProperties chain */
10075
10076 static inline size_t
vn_sizeof_VkExternalBufferProperties_pnext(const void * val)10077 vn_sizeof_VkExternalBufferProperties_pnext(const void *val)
10078 {
10079 /* no known/supported struct */
10080 return vn_sizeof_simple_pointer(NULL);
10081 }
10082
10083 static inline size_t
vn_sizeof_VkExternalBufferProperties_self(const VkExternalBufferProperties * val)10084 vn_sizeof_VkExternalBufferProperties_self(const VkExternalBufferProperties *val)
10085 {
10086 size_t size = 0;
10087 /* skip val->{sType,pNext} */
10088 size += vn_sizeof_VkExternalMemoryProperties(&val->externalMemoryProperties);
10089 return size;
10090 }
10091
10092 static inline size_t
vn_sizeof_VkExternalBufferProperties(const VkExternalBufferProperties * val)10093 vn_sizeof_VkExternalBufferProperties(const VkExternalBufferProperties *val)
10094 {
10095 size_t size = 0;
10096
10097 size += vn_sizeof_VkStructureType(&val->sType);
10098 size += vn_sizeof_VkExternalBufferProperties_pnext(val->pNext);
10099 size += vn_sizeof_VkExternalBufferProperties_self(val);
10100
10101 return size;
10102 }
10103
10104 static inline void
vn_decode_VkExternalBufferProperties_pnext(struct vn_cs_decoder * dec,const void * val)10105 vn_decode_VkExternalBufferProperties_pnext(struct vn_cs_decoder *dec, const void *val)
10106 {
10107 /* no known/supported struct */
10108 if (vn_decode_simple_pointer(dec))
10109 assert(false);
10110 }
10111
10112 static inline void
vn_decode_VkExternalBufferProperties_self(struct vn_cs_decoder * dec,VkExternalBufferProperties * val)10113 vn_decode_VkExternalBufferProperties_self(struct vn_cs_decoder *dec, VkExternalBufferProperties *val)
10114 {
10115 /* skip val->{sType,pNext} */
10116 vn_decode_VkExternalMemoryProperties(dec, &val->externalMemoryProperties);
10117 }
10118
10119 static inline void
vn_decode_VkExternalBufferProperties(struct vn_cs_decoder * dec,VkExternalBufferProperties * val)10120 vn_decode_VkExternalBufferProperties(struct vn_cs_decoder *dec, VkExternalBufferProperties *val)
10121 {
10122 VkStructureType stype;
10123 vn_decode_VkStructureType(dec, &stype);
10124 assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES);
10125
10126 assert(val->sType == stype);
10127 vn_decode_VkExternalBufferProperties_pnext(dec, val->pNext);
10128 vn_decode_VkExternalBufferProperties_self(dec, val);
10129 }
10130
10131 static inline size_t
vn_sizeof_VkExternalBufferProperties_pnext_partial(const void * val)10132 vn_sizeof_VkExternalBufferProperties_pnext_partial(const void *val)
10133 {
10134 /* no known/supported struct */
10135 return vn_sizeof_simple_pointer(NULL);
10136 }
10137
10138 static inline size_t
vn_sizeof_VkExternalBufferProperties_self_partial(const VkExternalBufferProperties * val)10139 vn_sizeof_VkExternalBufferProperties_self_partial(const VkExternalBufferProperties *val)
10140 {
10141 size_t size = 0;
10142 /* skip val->{sType,pNext} */
10143 size += vn_sizeof_VkExternalMemoryProperties_partial(&val->externalMemoryProperties);
10144 return size;
10145 }
10146
10147 static inline size_t
vn_sizeof_VkExternalBufferProperties_partial(const VkExternalBufferProperties * val)10148 vn_sizeof_VkExternalBufferProperties_partial(const VkExternalBufferProperties *val)
10149 {
10150 size_t size = 0;
10151
10152 size += vn_sizeof_VkStructureType(&val->sType);
10153 size += vn_sizeof_VkExternalBufferProperties_pnext_partial(val->pNext);
10154 size += vn_sizeof_VkExternalBufferProperties_self_partial(val);
10155
10156 return size;
10157 }
10158
10159 static inline void
vn_encode_VkExternalBufferProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)10160 vn_encode_VkExternalBufferProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
10161 {
10162 /* no known/supported struct */
10163 vn_encode_simple_pointer(enc, NULL);
10164 }
10165
10166 static inline void
vn_encode_VkExternalBufferProperties_self_partial(struct vn_cs_encoder * enc,const VkExternalBufferProperties * val)10167 vn_encode_VkExternalBufferProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalBufferProperties *val)
10168 {
10169 /* skip val->{sType,pNext} */
10170 vn_encode_VkExternalMemoryProperties_partial(enc, &val->externalMemoryProperties);
10171 }
10172
10173 static inline void
vn_encode_VkExternalBufferProperties_partial(struct vn_cs_encoder * enc,const VkExternalBufferProperties * val)10174 vn_encode_VkExternalBufferProperties_partial(struct vn_cs_encoder *enc, const VkExternalBufferProperties *val)
10175 {
10176 assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES);
10177 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES });
10178 vn_encode_VkExternalBufferProperties_pnext_partial(enc, val->pNext);
10179 vn_encode_VkExternalBufferProperties_self_partial(enc, val);
10180 }
10181
10182 /* struct VkPhysicalDeviceExternalSemaphoreInfo chain */
10183
10184 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(const void * val)10185 vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(const void *val)
10186 {
10187 const VkBaseInStructure *pnext = val;
10188 size_t size = 0;
10189
10190 while (pnext) {
10191 switch ((int32_t)pnext->sType) {
10192 case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
10193 size += vn_sizeof_simple_pointer(pnext);
10194 size += vn_sizeof_VkStructureType(&pnext->sType);
10195 size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(pnext->pNext);
10196 size += vn_sizeof_VkSemaphoreTypeCreateInfo_self((const VkSemaphoreTypeCreateInfo *)pnext);
10197 return size;
10198 default:
10199 /* ignore unknown/unsupported struct */
10200 break;
10201 }
10202 pnext = pnext->pNext;
10203 }
10204
10205 return vn_sizeof_simple_pointer(NULL);
10206 }
10207
10208 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_self(const VkPhysicalDeviceExternalSemaphoreInfo * val)10209 vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_self(const VkPhysicalDeviceExternalSemaphoreInfo *val)
10210 {
10211 size_t size = 0;
10212 /* skip val->{sType,pNext} */
10213 size += vn_sizeof_VkExternalSemaphoreHandleTypeFlagBits(&val->handleType);
10214 return size;
10215 }
10216
10217 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo * val)10218 vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo *val)
10219 {
10220 size_t size = 0;
10221
10222 size += vn_sizeof_VkStructureType(&val->sType);
10223 size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(val->pNext);
10224 size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_self(val);
10225
10226 return size;
10227 }
10228
10229 static inline void
vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(struct vn_cs_encoder * enc,const void * val)10230 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(struct vn_cs_encoder *enc, const void *val)
10231 {
10232 const VkBaseInStructure *pnext = val;
10233
10234 while (pnext) {
10235 switch ((int32_t)pnext->sType) {
10236 case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
10237 vn_encode_simple_pointer(enc, pnext);
10238 vn_encode_VkStructureType(enc, &pnext->sType);
10239 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(enc, pnext->pNext);
10240 vn_encode_VkSemaphoreTypeCreateInfo_self(enc, (const VkSemaphoreTypeCreateInfo *)pnext);
10241 return;
10242 default:
10243 /* ignore unknown/unsupported struct */
10244 break;
10245 }
10246 pnext = pnext->pNext;
10247 }
10248
10249 vn_encode_simple_pointer(enc, NULL);
10250 }
10251
10252 static inline void
vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalSemaphoreInfo * val)10253 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalSemaphoreInfo *val)
10254 {
10255 /* skip val->{sType,pNext} */
10256 vn_encode_VkExternalSemaphoreHandleTypeFlagBits(enc, &val->handleType);
10257 }
10258
10259 static inline void
vn_encode_VkPhysicalDeviceExternalSemaphoreInfo(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalSemaphoreInfo * val)10260 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalSemaphoreInfo *val)
10261 {
10262 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO);
10263 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO });
10264 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(enc, val->pNext);
10265 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_self(enc, val);
10266 }
10267
10268 /* struct VkExternalSemaphoreProperties chain */
10269
10270 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_pnext(const void * val)10271 vn_sizeof_VkExternalSemaphoreProperties_pnext(const void *val)
10272 {
10273 /* no known/supported struct */
10274 return vn_sizeof_simple_pointer(NULL);
10275 }
10276
10277 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_self(const VkExternalSemaphoreProperties * val)10278 vn_sizeof_VkExternalSemaphoreProperties_self(const VkExternalSemaphoreProperties *val)
10279 {
10280 size_t size = 0;
10281 /* skip val->{sType,pNext} */
10282 size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes);
10283 size += vn_sizeof_VkFlags(&val->compatibleHandleTypes);
10284 size += vn_sizeof_VkFlags(&val->externalSemaphoreFeatures);
10285 return size;
10286 }
10287
10288 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties * val)10289 vn_sizeof_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties *val)
10290 {
10291 size_t size = 0;
10292
10293 size += vn_sizeof_VkStructureType(&val->sType);
10294 size += vn_sizeof_VkExternalSemaphoreProperties_pnext(val->pNext);
10295 size += vn_sizeof_VkExternalSemaphoreProperties_self(val);
10296
10297 return size;
10298 }
10299
10300 static inline void
vn_decode_VkExternalSemaphoreProperties_pnext(struct vn_cs_decoder * dec,const void * val)10301 vn_decode_VkExternalSemaphoreProperties_pnext(struct vn_cs_decoder *dec, const void *val)
10302 {
10303 /* no known/supported struct */
10304 if (vn_decode_simple_pointer(dec))
10305 assert(false);
10306 }
10307
10308 static inline void
vn_decode_VkExternalSemaphoreProperties_self(struct vn_cs_decoder * dec,VkExternalSemaphoreProperties * val)10309 vn_decode_VkExternalSemaphoreProperties_self(struct vn_cs_decoder *dec, VkExternalSemaphoreProperties *val)
10310 {
10311 /* skip val->{sType,pNext} */
10312 vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes);
10313 vn_decode_VkFlags(dec, &val->compatibleHandleTypes);
10314 vn_decode_VkFlags(dec, &val->externalSemaphoreFeatures);
10315 }
10316
10317 static inline void
vn_decode_VkExternalSemaphoreProperties(struct vn_cs_decoder * dec,VkExternalSemaphoreProperties * val)10318 vn_decode_VkExternalSemaphoreProperties(struct vn_cs_decoder *dec, VkExternalSemaphoreProperties *val)
10319 {
10320 VkStructureType stype;
10321 vn_decode_VkStructureType(dec, &stype);
10322 assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES);
10323
10324 assert(val->sType == stype);
10325 vn_decode_VkExternalSemaphoreProperties_pnext(dec, val->pNext);
10326 vn_decode_VkExternalSemaphoreProperties_self(dec, val);
10327 }
10328
10329 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_pnext_partial(const void * val)10330 vn_sizeof_VkExternalSemaphoreProperties_pnext_partial(const void *val)
10331 {
10332 /* no known/supported struct */
10333 return vn_sizeof_simple_pointer(NULL);
10334 }
10335
10336 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_self_partial(const VkExternalSemaphoreProperties * val)10337 vn_sizeof_VkExternalSemaphoreProperties_self_partial(const VkExternalSemaphoreProperties *val)
10338 {
10339 size_t size = 0;
10340 /* skip val->{sType,pNext} */
10341 /* skip val->exportFromImportedHandleTypes */
10342 /* skip val->compatibleHandleTypes */
10343 /* skip val->externalSemaphoreFeatures */
10344 return size;
10345 }
10346
10347 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_partial(const VkExternalSemaphoreProperties * val)10348 vn_sizeof_VkExternalSemaphoreProperties_partial(const VkExternalSemaphoreProperties *val)
10349 {
10350 size_t size = 0;
10351
10352 size += vn_sizeof_VkStructureType(&val->sType);
10353 size += vn_sizeof_VkExternalSemaphoreProperties_pnext_partial(val->pNext);
10354 size += vn_sizeof_VkExternalSemaphoreProperties_self_partial(val);
10355
10356 return size;
10357 }
10358
10359 static inline void
vn_encode_VkExternalSemaphoreProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)10360 vn_encode_VkExternalSemaphoreProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
10361 {
10362 /* no known/supported struct */
10363 vn_encode_simple_pointer(enc, NULL);
10364 }
10365
10366 static inline void
vn_encode_VkExternalSemaphoreProperties_self_partial(struct vn_cs_encoder * enc,const VkExternalSemaphoreProperties * val)10367 vn_encode_VkExternalSemaphoreProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalSemaphoreProperties *val)
10368 {
10369 /* skip val->{sType,pNext} */
10370 /* skip val->exportFromImportedHandleTypes */
10371 /* skip val->compatibleHandleTypes */
10372 /* skip val->externalSemaphoreFeatures */
10373 }
10374
10375 static inline void
vn_encode_VkExternalSemaphoreProperties_partial(struct vn_cs_encoder * enc,const VkExternalSemaphoreProperties * val)10376 vn_encode_VkExternalSemaphoreProperties_partial(struct vn_cs_encoder *enc, const VkExternalSemaphoreProperties *val)
10377 {
10378 assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES);
10379 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES });
10380 vn_encode_VkExternalSemaphoreProperties_pnext_partial(enc, val->pNext);
10381 vn_encode_VkExternalSemaphoreProperties_self_partial(enc, val);
10382 }
10383
10384 /* struct VkPhysicalDeviceExternalFenceInfo chain */
10385
10386 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalFenceInfo_pnext(const void * val)10387 vn_sizeof_VkPhysicalDeviceExternalFenceInfo_pnext(const void *val)
10388 {
10389 /* no known/supported struct */
10390 return vn_sizeof_simple_pointer(NULL);
10391 }
10392
10393 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalFenceInfo_self(const VkPhysicalDeviceExternalFenceInfo * val)10394 vn_sizeof_VkPhysicalDeviceExternalFenceInfo_self(const VkPhysicalDeviceExternalFenceInfo *val)
10395 {
10396 size_t size = 0;
10397 /* skip val->{sType,pNext} */
10398 size += vn_sizeof_VkExternalFenceHandleTypeFlagBits(&val->handleType);
10399 return size;
10400 }
10401
10402 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo * val)10403 vn_sizeof_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo *val)
10404 {
10405 size_t size = 0;
10406
10407 size += vn_sizeof_VkStructureType(&val->sType);
10408 size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo_pnext(val->pNext);
10409 size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo_self(val);
10410
10411 return size;
10412 }
10413
10414 static inline void
vn_encode_VkPhysicalDeviceExternalFenceInfo_pnext(struct vn_cs_encoder * enc,const void * val)10415 vn_encode_VkPhysicalDeviceExternalFenceInfo_pnext(struct vn_cs_encoder *enc, const void *val)
10416 {
10417 /* no known/supported struct */
10418 vn_encode_simple_pointer(enc, NULL);
10419 }
10420
10421 static inline void
vn_encode_VkPhysicalDeviceExternalFenceInfo_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalFenceInfo * val)10422 vn_encode_VkPhysicalDeviceExternalFenceInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalFenceInfo *val)
10423 {
10424 /* skip val->{sType,pNext} */
10425 vn_encode_VkExternalFenceHandleTypeFlagBits(enc, &val->handleType);
10426 }
10427
10428 static inline void
vn_encode_VkPhysicalDeviceExternalFenceInfo(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalFenceInfo * val)10429 vn_encode_VkPhysicalDeviceExternalFenceInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalFenceInfo *val)
10430 {
10431 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO);
10432 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO });
10433 vn_encode_VkPhysicalDeviceExternalFenceInfo_pnext(enc, val->pNext);
10434 vn_encode_VkPhysicalDeviceExternalFenceInfo_self(enc, val);
10435 }
10436
10437 /* struct VkExternalFenceProperties chain */
10438
10439 static inline size_t
vn_sizeof_VkExternalFenceProperties_pnext(const void * val)10440 vn_sizeof_VkExternalFenceProperties_pnext(const void *val)
10441 {
10442 /* no known/supported struct */
10443 return vn_sizeof_simple_pointer(NULL);
10444 }
10445
10446 static inline size_t
vn_sizeof_VkExternalFenceProperties_self(const VkExternalFenceProperties * val)10447 vn_sizeof_VkExternalFenceProperties_self(const VkExternalFenceProperties *val)
10448 {
10449 size_t size = 0;
10450 /* skip val->{sType,pNext} */
10451 size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes);
10452 size += vn_sizeof_VkFlags(&val->compatibleHandleTypes);
10453 size += vn_sizeof_VkFlags(&val->externalFenceFeatures);
10454 return size;
10455 }
10456
10457 static inline size_t
vn_sizeof_VkExternalFenceProperties(const VkExternalFenceProperties * val)10458 vn_sizeof_VkExternalFenceProperties(const VkExternalFenceProperties *val)
10459 {
10460 size_t size = 0;
10461
10462 size += vn_sizeof_VkStructureType(&val->sType);
10463 size += vn_sizeof_VkExternalFenceProperties_pnext(val->pNext);
10464 size += vn_sizeof_VkExternalFenceProperties_self(val);
10465
10466 return size;
10467 }
10468
10469 static inline void
vn_decode_VkExternalFenceProperties_pnext(struct vn_cs_decoder * dec,const void * val)10470 vn_decode_VkExternalFenceProperties_pnext(struct vn_cs_decoder *dec, const void *val)
10471 {
10472 /* no known/supported struct */
10473 if (vn_decode_simple_pointer(dec))
10474 assert(false);
10475 }
10476
10477 static inline void
vn_decode_VkExternalFenceProperties_self(struct vn_cs_decoder * dec,VkExternalFenceProperties * val)10478 vn_decode_VkExternalFenceProperties_self(struct vn_cs_decoder *dec, VkExternalFenceProperties *val)
10479 {
10480 /* skip val->{sType,pNext} */
10481 vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes);
10482 vn_decode_VkFlags(dec, &val->compatibleHandleTypes);
10483 vn_decode_VkFlags(dec, &val->externalFenceFeatures);
10484 }
10485
10486 static inline void
vn_decode_VkExternalFenceProperties(struct vn_cs_decoder * dec,VkExternalFenceProperties * val)10487 vn_decode_VkExternalFenceProperties(struct vn_cs_decoder *dec, VkExternalFenceProperties *val)
10488 {
10489 VkStructureType stype;
10490 vn_decode_VkStructureType(dec, &stype);
10491 assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES);
10492
10493 assert(val->sType == stype);
10494 vn_decode_VkExternalFenceProperties_pnext(dec, val->pNext);
10495 vn_decode_VkExternalFenceProperties_self(dec, val);
10496 }
10497
10498 static inline size_t
vn_sizeof_VkExternalFenceProperties_pnext_partial(const void * val)10499 vn_sizeof_VkExternalFenceProperties_pnext_partial(const void *val)
10500 {
10501 /* no known/supported struct */
10502 return vn_sizeof_simple_pointer(NULL);
10503 }
10504
10505 static inline size_t
vn_sizeof_VkExternalFenceProperties_self_partial(const VkExternalFenceProperties * val)10506 vn_sizeof_VkExternalFenceProperties_self_partial(const VkExternalFenceProperties *val)
10507 {
10508 size_t size = 0;
10509 /* skip val->{sType,pNext} */
10510 /* skip val->exportFromImportedHandleTypes */
10511 /* skip val->compatibleHandleTypes */
10512 /* skip val->externalFenceFeatures */
10513 return size;
10514 }
10515
10516 static inline size_t
vn_sizeof_VkExternalFenceProperties_partial(const VkExternalFenceProperties * val)10517 vn_sizeof_VkExternalFenceProperties_partial(const VkExternalFenceProperties *val)
10518 {
10519 size_t size = 0;
10520
10521 size += vn_sizeof_VkStructureType(&val->sType);
10522 size += vn_sizeof_VkExternalFenceProperties_pnext_partial(val->pNext);
10523 size += vn_sizeof_VkExternalFenceProperties_self_partial(val);
10524
10525 return size;
10526 }
10527
10528 static inline void
vn_encode_VkExternalFenceProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)10529 vn_encode_VkExternalFenceProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
10530 {
10531 /* no known/supported struct */
10532 vn_encode_simple_pointer(enc, NULL);
10533 }
10534
10535 static inline void
vn_encode_VkExternalFenceProperties_self_partial(struct vn_cs_encoder * enc,const VkExternalFenceProperties * val)10536 vn_encode_VkExternalFenceProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalFenceProperties *val)
10537 {
10538 /* skip val->{sType,pNext} */
10539 /* skip val->exportFromImportedHandleTypes */
10540 /* skip val->compatibleHandleTypes */
10541 /* skip val->externalFenceFeatures */
10542 }
10543
10544 static inline void
vn_encode_VkExternalFenceProperties_partial(struct vn_cs_encoder * enc,const VkExternalFenceProperties * val)10545 vn_encode_VkExternalFenceProperties_partial(struct vn_cs_encoder *enc, const VkExternalFenceProperties *val)
10546 {
10547 assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES);
10548 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES });
10549 vn_encode_VkExternalFenceProperties_pnext_partial(enc, val->pNext);
10550 vn_encode_VkExternalFenceProperties_self_partial(enc, val);
10551 }
10552
10553 /* struct VkPhysicalDeviceGroupProperties chain */
10554
10555 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_pnext(const void * val)10556 vn_sizeof_VkPhysicalDeviceGroupProperties_pnext(const void *val)
10557 {
10558 /* no known/supported struct */
10559 return vn_sizeof_simple_pointer(NULL);
10560 }
10561
10562 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_self(const VkPhysicalDeviceGroupProperties * val)10563 vn_sizeof_VkPhysicalDeviceGroupProperties_self(const VkPhysicalDeviceGroupProperties *val)
10564 {
10565 size_t size = 0;
10566 /* skip val->{sType,pNext} */
10567 size += vn_sizeof_uint32_t(&val->physicalDeviceCount);
10568 size += vn_sizeof_array_size(VK_MAX_DEVICE_GROUP_SIZE);
10569 for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
10570 size += vn_sizeof_VkPhysicalDevice(&val->physicalDevices[i]);
10571 size += vn_sizeof_VkBool32(&val->subsetAllocation);
10572 return size;
10573 }
10574
10575 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties * val)10576 vn_sizeof_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties *val)
10577 {
10578 size_t size = 0;
10579
10580 size += vn_sizeof_VkStructureType(&val->sType);
10581 size += vn_sizeof_VkPhysicalDeviceGroupProperties_pnext(val->pNext);
10582 size += vn_sizeof_VkPhysicalDeviceGroupProperties_self(val);
10583
10584 return size;
10585 }
10586
10587 static inline void
vn_decode_VkPhysicalDeviceGroupProperties_pnext(struct vn_cs_decoder * dec,const void * val)10588 vn_decode_VkPhysicalDeviceGroupProperties_pnext(struct vn_cs_decoder *dec, const void *val)
10589 {
10590 /* no known/supported struct */
10591 if (vn_decode_simple_pointer(dec))
10592 assert(false);
10593 }
10594
10595 static inline void
vn_decode_VkPhysicalDeviceGroupProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceGroupProperties * val)10596 vn_decode_VkPhysicalDeviceGroupProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceGroupProperties *val)
10597 {
10598 /* skip val->{sType,pNext} */
10599 vn_decode_uint32_t(dec, &val->physicalDeviceCount);
10600 {
10601 const uint32_t iter_count = vn_decode_array_size(dec, VK_MAX_DEVICE_GROUP_SIZE);
10602 for (uint32_t i = 0; i < iter_count; i++)
10603 vn_decode_VkPhysicalDevice(dec, &val->physicalDevices[i]);
10604 }
10605 vn_decode_VkBool32(dec, &val->subsetAllocation);
10606 }
10607
10608 static inline void
vn_decode_VkPhysicalDeviceGroupProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceGroupProperties * val)10609 vn_decode_VkPhysicalDeviceGroupProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceGroupProperties *val)
10610 {
10611 VkStructureType stype;
10612 vn_decode_VkStructureType(dec, &stype);
10613 assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES);
10614
10615 assert(val->sType == stype);
10616 vn_decode_VkPhysicalDeviceGroupProperties_pnext(dec, val->pNext);
10617 vn_decode_VkPhysicalDeviceGroupProperties_self(dec, val);
10618 }
10619
10620 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_pnext_partial(const void * val)10621 vn_sizeof_VkPhysicalDeviceGroupProperties_pnext_partial(const void *val)
10622 {
10623 /* no known/supported struct */
10624 return vn_sizeof_simple_pointer(NULL);
10625 }
10626
10627 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_self_partial(const VkPhysicalDeviceGroupProperties * val)10628 vn_sizeof_VkPhysicalDeviceGroupProperties_self_partial(const VkPhysicalDeviceGroupProperties *val)
10629 {
10630 size_t size = 0;
10631 /* skip val->{sType,pNext} */
10632 /* skip val->physicalDeviceCount */
10633 size += vn_sizeof_array_size(VK_MAX_DEVICE_GROUP_SIZE);
10634 for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
10635 size += vn_sizeof_VkPhysicalDevice(&val->physicalDevices[i]);
10636 /* skip val->subsetAllocation */
10637 return size;
10638 }
10639
10640 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_partial(const VkPhysicalDeviceGroupProperties * val)10641 vn_sizeof_VkPhysicalDeviceGroupProperties_partial(const VkPhysicalDeviceGroupProperties *val)
10642 {
10643 size_t size = 0;
10644
10645 size += vn_sizeof_VkStructureType(&val->sType);
10646 size += vn_sizeof_VkPhysicalDeviceGroupProperties_pnext_partial(val->pNext);
10647 size += vn_sizeof_VkPhysicalDeviceGroupProperties_self_partial(val);
10648
10649 return size;
10650 }
10651
10652 static inline void
vn_encode_VkPhysicalDeviceGroupProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)10653 vn_encode_VkPhysicalDeviceGroupProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
10654 {
10655 /* no known/supported struct */
10656 vn_encode_simple_pointer(enc, NULL);
10657 }
10658
10659 static inline void
vn_encode_VkPhysicalDeviceGroupProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceGroupProperties * val)10660 vn_encode_VkPhysicalDeviceGroupProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceGroupProperties *val)
10661 {
10662 /* skip val->{sType,pNext} */
10663 /* skip val->physicalDeviceCount */
10664 vn_encode_array_size(enc, VK_MAX_DEVICE_GROUP_SIZE);
10665 for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
10666 vn_encode_VkPhysicalDevice(enc, &val->physicalDevices[i]);
10667 /* skip val->subsetAllocation */
10668 }
10669
10670 static inline void
vn_encode_VkPhysicalDeviceGroupProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceGroupProperties * val)10671 vn_encode_VkPhysicalDeviceGroupProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceGroupProperties *val)
10672 {
10673 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES);
10674 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES });
10675 vn_encode_VkPhysicalDeviceGroupProperties_pnext_partial(enc, val->pNext);
10676 vn_encode_VkPhysicalDeviceGroupProperties_self_partial(enc, val);
10677 }
10678
10679 /* struct VkDeviceQueueInfo2 chain */
10680
10681 static inline size_t
vn_sizeof_VkDeviceQueueInfo2_pnext(const void * val)10682 vn_sizeof_VkDeviceQueueInfo2_pnext(const void *val)
10683 {
10684 /* no known/supported struct */
10685 return vn_sizeof_simple_pointer(NULL);
10686 }
10687
10688 static inline size_t
vn_sizeof_VkDeviceQueueInfo2_self(const VkDeviceQueueInfo2 * val)10689 vn_sizeof_VkDeviceQueueInfo2_self(const VkDeviceQueueInfo2 *val)
10690 {
10691 size_t size = 0;
10692 /* skip val->{sType,pNext} */
10693 size += vn_sizeof_VkFlags(&val->flags);
10694 size += vn_sizeof_uint32_t(&val->queueFamilyIndex);
10695 size += vn_sizeof_uint32_t(&val->queueIndex);
10696 return size;
10697 }
10698
10699 static inline size_t
vn_sizeof_VkDeviceQueueInfo2(const VkDeviceQueueInfo2 * val)10700 vn_sizeof_VkDeviceQueueInfo2(const VkDeviceQueueInfo2 *val)
10701 {
10702 size_t size = 0;
10703
10704 size += vn_sizeof_VkStructureType(&val->sType);
10705 size += vn_sizeof_VkDeviceQueueInfo2_pnext(val->pNext);
10706 size += vn_sizeof_VkDeviceQueueInfo2_self(val);
10707
10708 return size;
10709 }
10710
10711 static inline void
vn_encode_VkDeviceQueueInfo2_pnext(struct vn_cs_encoder * enc,const void * val)10712 vn_encode_VkDeviceQueueInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
10713 {
10714 /* no known/supported struct */
10715 vn_encode_simple_pointer(enc, NULL);
10716 }
10717
10718 static inline void
vn_encode_VkDeviceQueueInfo2_self(struct vn_cs_encoder * enc,const VkDeviceQueueInfo2 * val)10719 vn_encode_VkDeviceQueueInfo2_self(struct vn_cs_encoder *enc, const VkDeviceQueueInfo2 *val)
10720 {
10721 /* skip val->{sType,pNext} */
10722 vn_encode_VkFlags(enc, &val->flags);
10723 vn_encode_uint32_t(enc, &val->queueFamilyIndex);
10724 vn_encode_uint32_t(enc, &val->queueIndex);
10725 }
10726
10727 static inline void
vn_encode_VkDeviceQueueInfo2(struct vn_cs_encoder * enc,const VkDeviceQueueInfo2 * val)10728 vn_encode_VkDeviceQueueInfo2(struct vn_cs_encoder *enc, const VkDeviceQueueInfo2 *val)
10729 {
10730 assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2);
10731 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 });
10732 vn_encode_VkDeviceQueueInfo2_pnext(enc, val->pNext);
10733 vn_encode_VkDeviceQueueInfo2_self(enc, val);
10734 }
10735
vn_sizeof_vkEnumeratePhysicalDevices(VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)10736 static inline size_t vn_sizeof_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
10737 {
10738 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT;
10739 const VkFlags cmd_flags = 0;
10740 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
10741
10742 cmd_size += vn_sizeof_VkInstance(&instance);
10743 cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceCount);
10744 if (pPhysicalDeviceCount)
10745 cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceCount);
10746 if (pPhysicalDevices) {
10747 cmd_size += vn_sizeof_array_size((pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0));
10748 for (uint32_t i = 0; i < (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0); i++)
10749 cmd_size += vn_sizeof_VkPhysicalDevice(&pPhysicalDevices[i]);
10750 } else {
10751 cmd_size += vn_sizeof_array_size(0);
10752 }
10753
10754 return cmd_size;
10755 }
10756
vn_encode_vkEnumeratePhysicalDevices(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)10757 static inline void vn_encode_vkEnumeratePhysicalDevices(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
10758 {
10759 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT;
10760
10761 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
10762 vn_encode_VkFlags(enc, &cmd_flags);
10763
10764 vn_encode_VkInstance(enc, &instance);
10765 if (vn_encode_simple_pointer(enc, pPhysicalDeviceCount))
10766 vn_encode_uint32_t(enc, pPhysicalDeviceCount);
10767 if (pPhysicalDevices) {
10768 vn_encode_array_size(enc, (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0));
10769 for (uint32_t i = 0; i < (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0); i++)
10770 vn_encode_VkPhysicalDevice(enc, &pPhysicalDevices[i]);
10771 } else {
10772 vn_encode_array_size(enc, 0);
10773 }
10774 }
10775
vn_sizeof_vkEnumeratePhysicalDevices_reply(VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)10776 static inline size_t vn_sizeof_vkEnumeratePhysicalDevices_reply(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
10777 {
10778 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT;
10779 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
10780
10781 VkResult ret;
10782 cmd_size += vn_sizeof_VkResult(&ret);
10783 /* skip instance */
10784 cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceCount);
10785 if (pPhysicalDeviceCount)
10786 cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceCount);
10787 if (pPhysicalDevices) {
10788 cmd_size += vn_sizeof_array_size((pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0));
10789 for (uint32_t i = 0; i < (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0); i++)
10790 cmd_size += vn_sizeof_VkPhysicalDevice(&pPhysicalDevices[i]);
10791 } else {
10792 cmd_size += vn_sizeof_array_size(0);
10793 }
10794
10795 return cmd_size;
10796 }
10797
vn_decode_vkEnumeratePhysicalDevices_reply(struct vn_cs_decoder * dec,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)10798 static inline VkResult vn_decode_vkEnumeratePhysicalDevices_reply(struct vn_cs_decoder *dec, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
10799 {
10800 VkCommandTypeEXT command_type;
10801 vn_decode_VkCommandTypeEXT(dec, &command_type);
10802 assert(command_type == VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT);
10803
10804 VkResult ret;
10805 vn_decode_VkResult(dec, &ret);
10806 /* skip instance */
10807 if (vn_decode_simple_pointer(dec)) {
10808 vn_decode_uint32_t(dec, pPhysicalDeviceCount);
10809 } else {
10810 pPhysicalDeviceCount = NULL;
10811 }
10812 if (vn_peek_array_size(dec)) {
10813 const uint32_t iter_count = vn_decode_array_size(dec, (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0));
10814 for (uint32_t i = 0; i < iter_count; i++)
10815 vn_decode_VkPhysicalDevice(dec, &pPhysicalDevices[i]);
10816 } else {
10817 vn_decode_array_size_unchecked(dec);
10818 pPhysicalDevices = NULL;
10819 }
10820
10821 return ret;
10822 }
10823
vn_sizeof_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)10824 static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
10825 {
10826 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT;
10827 const VkFlags cmd_flags = 0;
10828 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
10829
10830 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
10831 cmd_size += vn_sizeof_simple_pointer(pProperties);
10832 if (pProperties)
10833 cmd_size += vn_sizeof_VkPhysicalDeviceProperties_partial(pProperties);
10834
10835 return cmd_size;
10836 }
10837
vn_encode_vkGetPhysicalDeviceProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)10838 static inline void vn_encode_vkGetPhysicalDeviceProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
10839 {
10840 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT;
10841
10842 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
10843 vn_encode_VkFlags(enc, &cmd_flags);
10844
10845 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
10846 if (vn_encode_simple_pointer(enc, pProperties))
10847 vn_encode_VkPhysicalDeviceProperties_partial(enc, pProperties);
10848 }
10849
vn_sizeof_vkGetPhysicalDeviceProperties_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)10850 static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
10851 {
10852 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT;
10853 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
10854
10855 /* skip physicalDevice */
10856 cmd_size += vn_sizeof_simple_pointer(pProperties);
10857 if (pProperties)
10858 cmd_size += vn_sizeof_VkPhysicalDeviceProperties(pProperties);
10859
10860 return cmd_size;
10861 }
10862
vn_decode_vkGetPhysicalDeviceProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)10863 static inline void vn_decode_vkGetPhysicalDeviceProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
10864 {
10865 VkCommandTypeEXT command_type;
10866 vn_decode_VkCommandTypeEXT(dec, &command_type);
10867 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT);
10868
10869 /* skip physicalDevice */
10870 if (vn_decode_simple_pointer(dec)) {
10871 vn_decode_VkPhysicalDeviceProperties(dec, pProperties);
10872 } else {
10873 pProperties = NULL;
10874 }
10875 }
10876
vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)10877 static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
10878 {
10879 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT;
10880 const VkFlags cmd_flags = 0;
10881 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
10882
10883 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
10884 cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
10885 if (pQueueFamilyPropertyCount)
10886 cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
10887 if (pQueueFamilyProperties) {
10888 cmd_size += vn_sizeof_array_size((pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
10889 for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
10890 cmd_size += vn_sizeof_VkQueueFamilyProperties_partial(&pQueueFamilyProperties[i]);
10891 } else {
10892 cmd_size += vn_sizeof_array_size(0);
10893 }
10894
10895 return cmd_size;
10896 }
10897
vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)10898 static inline void vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
10899 {
10900 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT;
10901
10902 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
10903 vn_encode_VkFlags(enc, &cmd_flags);
10904
10905 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
10906 if (vn_encode_simple_pointer(enc, pQueueFamilyPropertyCount))
10907 vn_encode_uint32_t(enc, pQueueFamilyPropertyCount);
10908 if (pQueueFamilyProperties) {
10909 vn_encode_array_size(enc, (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
10910 for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
10911 vn_encode_VkQueueFamilyProperties_partial(enc, &pQueueFamilyProperties[i]);
10912 } else {
10913 vn_encode_array_size(enc, 0);
10914 }
10915 }
10916
vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)10917 static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
10918 {
10919 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT;
10920 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
10921
10922 /* skip physicalDevice */
10923 cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
10924 if (pQueueFamilyPropertyCount)
10925 cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
10926 if (pQueueFamilyProperties) {
10927 cmd_size += vn_sizeof_array_size((pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
10928 for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
10929 cmd_size += vn_sizeof_VkQueueFamilyProperties(&pQueueFamilyProperties[i]);
10930 } else {
10931 cmd_size += vn_sizeof_array_size(0);
10932 }
10933
10934 return cmd_size;
10935 }
10936
vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)10937 static inline void vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
10938 {
10939 VkCommandTypeEXT command_type;
10940 vn_decode_VkCommandTypeEXT(dec, &command_type);
10941 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT);
10942
10943 /* skip physicalDevice */
10944 if (vn_decode_simple_pointer(dec)) {
10945 vn_decode_uint32_t(dec, pQueueFamilyPropertyCount);
10946 } else {
10947 pQueueFamilyPropertyCount = NULL;
10948 }
10949 if (vn_peek_array_size(dec)) {
10950 const uint32_t iter_count = vn_decode_array_size(dec, (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
10951 for (uint32_t i = 0; i < iter_count; i++)
10952 vn_decode_VkQueueFamilyProperties(dec, &pQueueFamilyProperties[i]);
10953 } else {
10954 vn_decode_array_size_unchecked(dec);
10955 pQueueFamilyProperties = NULL;
10956 }
10957 }
10958
vn_sizeof_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)10959 static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
10960 {
10961 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT;
10962 const VkFlags cmd_flags = 0;
10963 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
10964
10965 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
10966 cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
10967 if (pMemoryProperties)
10968 cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(pMemoryProperties);
10969
10970 return cmd_size;
10971 }
10972
vn_encode_vkGetPhysicalDeviceMemoryProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)10973 static inline void vn_encode_vkGetPhysicalDeviceMemoryProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
10974 {
10975 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT;
10976
10977 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
10978 vn_encode_VkFlags(enc, &cmd_flags);
10979
10980 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
10981 if (vn_encode_simple_pointer(enc, pMemoryProperties))
10982 vn_encode_VkPhysicalDeviceMemoryProperties_partial(enc, pMemoryProperties);
10983 }
10984
vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)10985 static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
10986 {
10987 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT;
10988 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
10989
10990 /* skip physicalDevice */
10991 cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
10992 if (pMemoryProperties)
10993 cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties(pMemoryProperties);
10994
10995 return cmd_size;
10996 }
10997
vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)10998 static inline void vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
10999 {
11000 VkCommandTypeEXT command_type;
11001 vn_decode_VkCommandTypeEXT(dec, &command_type);
11002 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT);
11003
11004 /* skip physicalDevice */
11005 if (vn_decode_simple_pointer(dec)) {
11006 vn_decode_VkPhysicalDeviceMemoryProperties(dec, pMemoryProperties);
11007 } else {
11008 pMemoryProperties = NULL;
11009 }
11010 }
11011
vn_sizeof_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)11012 static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
11013 {
11014 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT;
11015 const VkFlags cmd_flags = 0;
11016 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11017
11018 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11019 cmd_size += vn_sizeof_simple_pointer(pFeatures);
11020 if (pFeatures)
11021 cmd_size += vn_sizeof_VkPhysicalDeviceFeatures_partial(pFeatures);
11022
11023 return cmd_size;
11024 }
11025
vn_encode_vkGetPhysicalDeviceFeatures(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)11026 static inline void vn_encode_vkGetPhysicalDeviceFeatures(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
11027 {
11028 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT;
11029
11030 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11031 vn_encode_VkFlags(enc, &cmd_flags);
11032
11033 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11034 if (vn_encode_simple_pointer(enc, pFeatures))
11035 vn_encode_VkPhysicalDeviceFeatures_partial(enc, pFeatures);
11036 }
11037
vn_sizeof_vkGetPhysicalDeviceFeatures_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)11038 static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
11039 {
11040 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT;
11041 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11042
11043 /* skip physicalDevice */
11044 cmd_size += vn_sizeof_simple_pointer(pFeatures);
11045 if (pFeatures)
11046 cmd_size += vn_sizeof_VkPhysicalDeviceFeatures(pFeatures);
11047
11048 return cmd_size;
11049 }
11050
vn_decode_vkGetPhysicalDeviceFeatures_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)11051 static inline void vn_decode_vkGetPhysicalDeviceFeatures_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
11052 {
11053 VkCommandTypeEXT command_type;
11054 vn_decode_VkCommandTypeEXT(dec, &command_type);
11055 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT);
11056
11057 /* skip physicalDevice */
11058 if (vn_decode_simple_pointer(dec)) {
11059 vn_decode_VkPhysicalDeviceFeatures(dec, pFeatures);
11060 } else {
11061 pFeatures = NULL;
11062 }
11063 }
11064
vn_sizeof_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)11065 static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
11066 {
11067 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT;
11068 const VkFlags cmd_flags = 0;
11069 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11070
11071 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11072 cmd_size += vn_sizeof_VkFormat(&format);
11073 cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
11074 if (pFormatProperties)
11075 cmd_size += vn_sizeof_VkFormatProperties_partial(pFormatProperties);
11076
11077 return cmd_size;
11078 }
11079
vn_encode_vkGetPhysicalDeviceFormatProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)11080 static inline void vn_encode_vkGetPhysicalDeviceFormatProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
11081 {
11082 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT;
11083
11084 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11085 vn_encode_VkFlags(enc, &cmd_flags);
11086
11087 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11088 vn_encode_VkFormat(enc, &format);
11089 if (vn_encode_simple_pointer(enc, pFormatProperties))
11090 vn_encode_VkFormatProperties_partial(enc, pFormatProperties);
11091 }
11092
vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)11093 static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
11094 {
11095 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT;
11096 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11097
11098 /* skip physicalDevice */
11099 /* skip format */
11100 cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
11101 if (pFormatProperties)
11102 cmd_size += vn_sizeof_VkFormatProperties(pFormatProperties);
11103
11104 return cmd_size;
11105 }
11106
vn_decode_vkGetPhysicalDeviceFormatProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)11107 static inline void vn_decode_vkGetPhysicalDeviceFormatProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
11108 {
11109 VkCommandTypeEXT command_type;
11110 vn_decode_VkCommandTypeEXT(dec, &command_type);
11111 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT);
11112
11113 /* skip physicalDevice */
11114 /* skip format */
11115 if (vn_decode_simple_pointer(dec)) {
11116 vn_decode_VkFormatProperties(dec, pFormatProperties);
11117 } else {
11118 pFormatProperties = NULL;
11119 }
11120 }
11121
vn_sizeof_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)11122 static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
11123 {
11124 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT;
11125 const VkFlags cmd_flags = 0;
11126 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11127
11128 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11129 cmd_size += vn_sizeof_VkFormat(&format);
11130 cmd_size += vn_sizeof_VkImageType(&type);
11131 cmd_size += vn_sizeof_VkImageTiling(&tiling);
11132 cmd_size += vn_sizeof_VkFlags(&usage);
11133 cmd_size += vn_sizeof_VkFlags(&flags);
11134 cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
11135 if (pImageFormatProperties)
11136 cmd_size += vn_sizeof_VkImageFormatProperties_partial(pImageFormatProperties);
11137
11138 return cmd_size;
11139 }
11140
vn_encode_vkGetPhysicalDeviceImageFormatProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)11141 static inline void vn_encode_vkGetPhysicalDeviceImageFormatProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
11142 {
11143 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT;
11144
11145 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11146 vn_encode_VkFlags(enc, &cmd_flags);
11147
11148 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11149 vn_encode_VkFormat(enc, &format);
11150 vn_encode_VkImageType(enc, &type);
11151 vn_encode_VkImageTiling(enc, &tiling);
11152 vn_encode_VkFlags(enc, &usage);
11153 vn_encode_VkFlags(enc, &flags);
11154 if (vn_encode_simple_pointer(enc, pImageFormatProperties))
11155 vn_encode_VkImageFormatProperties_partial(enc, pImageFormatProperties);
11156 }
11157
vn_sizeof_vkGetPhysicalDeviceImageFormatProperties_reply(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)11158 static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
11159 {
11160 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT;
11161 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11162
11163 VkResult ret;
11164 cmd_size += vn_sizeof_VkResult(&ret);
11165 /* skip physicalDevice */
11166 /* skip format */
11167 /* skip type */
11168 /* skip tiling */
11169 /* skip usage */
11170 /* skip flags */
11171 cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
11172 if (pImageFormatProperties)
11173 cmd_size += vn_sizeof_VkImageFormatProperties(pImageFormatProperties);
11174
11175 return cmd_size;
11176 }
11177
vn_decode_vkGetPhysicalDeviceImageFormatProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)11178 static inline VkResult vn_decode_vkGetPhysicalDeviceImageFormatProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
11179 {
11180 VkCommandTypeEXT command_type;
11181 vn_decode_VkCommandTypeEXT(dec, &command_type);
11182 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT);
11183
11184 VkResult ret;
11185 vn_decode_VkResult(dec, &ret);
11186 /* skip physicalDevice */
11187 /* skip format */
11188 /* skip type */
11189 /* skip tiling */
11190 /* skip usage */
11191 /* skip flags */
11192 if (vn_decode_simple_pointer(dec)) {
11193 vn_decode_VkImageFormatProperties(dec, pImageFormatProperties);
11194 } else {
11195 pImageFormatProperties = NULL;
11196 }
11197
11198 return ret;
11199 }
11200
vn_sizeof_vkCreateDevice(VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)11201 static inline size_t vn_sizeof_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
11202 {
11203 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT;
11204 const VkFlags cmd_flags = 0;
11205 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11206
11207 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11208 cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
11209 if (pCreateInfo)
11210 cmd_size += vn_sizeof_VkDeviceCreateInfo(pCreateInfo);
11211 cmd_size += vn_sizeof_simple_pointer(pAllocator);
11212 if (pAllocator)
11213 assert(false);
11214 cmd_size += vn_sizeof_simple_pointer(pDevice);
11215 if (pDevice)
11216 cmd_size += vn_sizeof_VkDevice(pDevice);
11217
11218 return cmd_size;
11219 }
11220
vn_encode_vkCreateDevice(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)11221 static inline void vn_encode_vkCreateDevice(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
11222 {
11223 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT;
11224
11225 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11226 vn_encode_VkFlags(enc, &cmd_flags);
11227
11228 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11229 if (vn_encode_simple_pointer(enc, pCreateInfo))
11230 vn_encode_VkDeviceCreateInfo(enc, pCreateInfo);
11231 if (vn_encode_simple_pointer(enc, pAllocator))
11232 assert(false);
11233 if (vn_encode_simple_pointer(enc, pDevice))
11234 vn_encode_VkDevice(enc, pDevice);
11235 }
11236
vn_sizeof_vkCreateDevice_reply(VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)11237 static inline size_t vn_sizeof_vkCreateDevice_reply(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
11238 {
11239 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT;
11240 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11241
11242 VkResult ret;
11243 cmd_size += vn_sizeof_VkResult(&ret);
11244 /* skip physicalDevice */
11245 /* skip pCreateInfo */
11246 /* skip pAllocator */
11247 cmd_size += vn_sizeof_simple_pointer(pDevice);
11248 if (pDevice)
11249 cmd_size += vn_sizeof_VkDevice(pDevice);
11250
11251 return cmd_size;
11252 }
11253
vn_decode_vkCreateDevice_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)11254 static inline VkResult vn_decode_vkCreateDevice_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
11255 {
11256 VkCommandTypeEXT command_type;
11257 vn_decode_VkCommandTypeEXT(dec, &command_type);
11258 assert(command_type == VK_COMMAND_TYPE_vkCreateDevice_EXT);
11259
11260 VkResult ret;
11261 vn_decode_VkResult(dec, &ret);
11262 /* skip physicalDevice */
11263 /* skip pCreateInfo */
11264 /* skip pAllocator */
11265 if (vn_decode_simple_pointer(dec)) {
11266 vn_decode_VkDevice(dec, pDevice);
11267 } else {
11268 pDevice = NULL;
11269 }
11270
11271 return ret;
11272 }
11273
vn_sizeof_vkDestroyDevice(VkDevice device,const VkAllocationCallbacks * pAllocator)11274 static inline size_t vn_sizeof_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
11275 {
11276 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT;
11277 const VkFlags cmd_flags = 0;
11278 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11279
11280 cmd_size += vn_sizeof_VkDevice(&device);
11281 cmd_size += vn_sizeof_simple_pointer(pAllocator);
11282 if (pAllocator)
11283 assert(false);
11284
11285 return cmd_size;
11286 }
11287
vn_encode_vkDestroyDevice(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkAllocationCallbacks * pAllocator)11288 static inline void vn_encode_vkDestroyDevice(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkAllocationCallbacks* pAllocator)
11289 {
11290 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT;
11291
11292 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11293 vn_encode_VkFlags(enc, &cmd_flags);
11294
11295 vn_encode_VkDevice(enc, &device);
11296 if (vn_encode_simple_pointer(enc, pAllocator))
11297 assert(false);
11298 }
11299
vn_sizeof_vkDestroyDevice_reply(VkDevice device,const VkAllocationCallbacks * pAllocator)11300 static inline size_t vn_sizeof_vkDestroyDevice_reply(VkDevice device, const VkAllocationCallbacks* pAllocator)
11301 {
11302 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT;
11303 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11304
11305 /* skip device */
11306 /* skip pAllocator */
11307
11308 return cmd_size;
11309 }
11310
vn_decode_vkDestroyDevice_reply(struct vn_cs_decoder * dec,VkDevice device,const VkAllocationCallbacks * pAllocator)11311 static inline void vn_decode_vkDestroyDevice_reply(struct vn_cs_decoder *dec, VkDevice device, const VkAllocationCallbacks* pAllocator)
11312 {
11313 VkCommandTypeEXT command_type;
11314 vn_decode_VkCommandTypeEXT(dec, &command_type);
11315 assert(command_type == VK_COMMAND_TYPE_vkDestroyDevice_EXT);
11316
11317 /* skip device */
11318 /* skip pAllocator */
11319 }
11320
vn_sizeof_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)11321 static inline size_t vn_sizeof_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
11322 {
11323 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT;
11324 const VkFlags cmd_flags = 0;
11325 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11326
11327 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11328 cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
11329 if (pPropertyCount)
11330 cmd_size += vn_sizeof_uint32_t(pPropertyCount);
11331 if (pProperties) {
11332 cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
11333 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
11334 cmd_size += vn_sizeof_VkLayerProperties_partial(&pProperties[i]);
11335 } else {
11336 cmd_size += vn_sizeof_array_size(0);
11337 }
11338
11339 return cmd_size;
11340 }
11341
vn_encode_vkEnumerateDeviceLayerProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)11342 static inline void vn_encode_vkEnumerateDeviceLayerProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
11343 {
11344 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT;
11345
11346 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11347 vn_encode_VkFlags(enc, &cmd_flags);
11348
11349 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11350 if (vn_encode_simple_pointer(enc, pPropertyCount))
11351 vn_encode_uint32_t(enc, pPropertyCount);
11352 if (pProperties) {
11353 vn_encode_array_size(enc, (pPropertyCount ? *pPropertyCount : 0));
11354 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
11355 vn_encode_VkLayerProperties_partial(enc, &pProperties[i]);
11356 } else {
11357 vn_encode_array_size(enc, 0);
11358 }
11359 }
11360
vn_sizeof_vkEnumerateDeviceLayerProperties_reply(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)11361 static inline size_t vn_sizeof_vkEnumerateDeviceLayerProperties_reply(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
11362 {
11363 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT;
11364 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11365
11366 VkResult ret;
11367 cmd_size += vn_sizeof_VkResult(&ret);
11368 /* skip physicalDevice */
11369 cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
11370 if (pPropertyCount)
11371 cmd_size += vn_sizeof_uint32_t(pPropertyCount);
11372 if (pProperties) {
11373 cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
11374 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
11375 cmd_size += vn_sizeof_VkLayerProperties(&pProperties[i]);
11376 } else {
11377 cmd_size += vn_sizeof_array_size(0);
11378 }
11379
11380 return cmd_size;
11381 }
11382
vn_decode_vkEnumerateDeviceLayerProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)11383 static inline VkResult vn_decode_vkEnumerateDeviceLayerProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
11384 {
11385 VkCommandTypeEXT command_type;
11386 vn_decode_VkCommandTypeEXT(dec, &command_type);
11387 assert(command_type == VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT);
11388
11389 VkResult ret;
11390 vn_decode_VkResult(dec, &ret);
11391 /* skip physicalDevice */
11392 if (vn_decode_simple_pointer(dec)) {
11393 vn_decode_uint32_t(dec, pPropertyCount);
11394 } else {
11395 pPropertyCount = NULL;
11396 }
11397 if (vn_peek_array_size(dec)) {
11398 const uint32_t iter_count = vn_decode_array_size(dec, (pPropertyCount ? *pPropertyCount : 0));
11399 for (uint32_t i = 0; i < iter_count; i++)
11400 vn_decode_VkLayerProperties(dec, &pProperties[i]);
11401 } else {
11402 vn_decode_array_size_unchecked(dec);
11403 pProperties = NULL;
11404 }
11405
11406 return ret;
11407 }
11408
vn_sizeof_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)11409 static inline size_t vn_sizeof_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
11410 {
11411 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT;
11412 const VkFlags cmd_flags = 0;
11413 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11414
11415 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11416 if (pLayerName) {
11417 const size_t string_size = strlen(pLayerName) + 1;
11418 cmd_size += vn_sizeof_array_size(string_size);
11419 cmd_size += vn_sizeof_char_array(pLayerName, string_size);
11420 } else {
11421 cmd_size += vn_sizeof_array_size(0);
11422 }
11423 cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
11424 if (pPropertyCount)
11425 cmd_size += vn_sizeof_uint32_t(pPropertyCount);
11426 if (pProperties) {
11427 cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
11428 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
11429 cmd_size += vn_sizeof_VkExtensionProperties_partial(&pProperties[i]);
11430 } else {
11431 cmd_size += vn_sizeof_array_size(0);
11432 }
11433
11434 return cmd_size;
11435 }
11436
vn_encode_vkEnumerateDeviceExtensionProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)11437 static inline void vn_encode_vkEnumerateDeviceExtensionProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
11438 {
11439 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT;
11440
11441 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11442 vn_encode_VkFlags(enc, &cmd_flags);
11443
11444 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11445 if (pLayerName) {
11446 const size_t string_size = strlen(pLayerName) + 1;
11447 vn_encode_array_size(enc, string_size);
11448 vn_encode_char_array(enc, pLayerName, string_size);
11449 } else {
11450 vn_encode_array_size(enc, 0);
11451 }
11452 if (vn_encode_simple_pointer(enc, pPropertyCount))
11453 vn_encode_uint32_t(enc, pPropertyCount);
11454 if (pProperties) {
11455 vn_encode_array_size(enc, (pPropertyCount ? *pPropertyCount : 0));
11456 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
11457 vn_encode_VkExtensionProperties_partial(enc, &pProperties[i]);
11458 } else {
11459 vn_encode_array_size(enc, 0);
11460 }
11461 }
11462
vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)11463 static inline size_t vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
11464 {
11465 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT;
11466 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11467
11468 VkResult ret;
11469 cmd_size += vn_sizeof_VkResult(&ret);
11470 /* skip physicalDevice */
11471 /* skip pLayerName */
11472 cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
11473 if (pPropertyCount)
11474 cmd_size += vn_sizeof_uint32_t(pPropertyCount);
11475 if (pProperties) {
11476 cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
11477 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
11478 cmd_size += vn_sizeof_VkExtensionProperties(&pProperties[i]);
11479 } else {
11480 cmd_size += vn_sizeof_array_size(0);
11481 }
11482
11483 return cmd_size;
11484 }
11485
vn_decode_vkEnumerateDeviceExtensionProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)11486 static inline VkResult vn_decode_vkEnumerateDeviceExtensionProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
11487 {
11488 VkCommandTypeEXT command_type;
11489 vn_decode_VkCommandTypeEXT(dec, &command_type);
11490 assert(command_type == VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT);
11491
11492 VkResult ret;
11493 vn_decode_VkResult(dec, &ret);
11494 /* skip physicalDevice */
11495 /* skip pLayerName */
11496 if (vn_decode_simple_pointer(dec)) {
11497 vn_decode_uint32_t(dec, pPropertyCount);
11498 } else {
11499 pPropertyCount = NULL;
11500 }
11501 if (vn_peek_array_size(dec)) {
11502 const uint32_t iter_count = vn_decode_array_size(dec, (pPropertyCount ? *pPropertyCount : 0));
11503 for (uint32_t i = 0; i < iter_count; i++)
11504 vn_decode_VkExtensionProperties(dec, &pProperties[i]);
11505 } else {
11506 vn_decode_array_size_unchecked(dec);
11507 pProperties = NULL;
11508 }
11509
11510 return ret;
11511 }
11512
vn_sizeof_vkGetDeviceQueue(VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)11513 static inline size_t vn_sizeof_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
11514 {
11515 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT;
11516 const VkFlags cmd_flags = 0;
11517 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11518
11519 cmd_size += vn_sizeof_VkDevice(&device);
11520 cmd_size += vn_sizeof_uint32_t(&queueFamilyIndex);
11521 cmd_size += vn_sizeof_uint32_t(&queueIndex);
11522 cmd_size += vn_sizeof_simple_pointer(pQueue);
11523 if (pQueue)
11524 cmd_size += vn_sizeof_VkQueue(pQueue);
11525
11526 return cmd_size;
11527 }
11528
vn_encode_vkGetDeviceQueue(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)11529 static inline void vn_encode_vkGetDeviceQueue(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
11530 {
11531 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT;
11532
11533 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11534 vn_encode_VkFlags(enc, &cmd_flags);
11535
11536 vn_encode_VkDevice(enc, &device);
11537 vn_encode_uint32_t(enc, &queueFamilyIndex);
11538 vn_encode_uint32_t(enc, &queueIndex);
11539 if (vn_encode_simple_pointer(enc, pQueue))
11540 vn_encode_VkQueue(enc, pQueue);
11541 }
11542
vn_sizeof_vkGetDeviceQueue_reply(VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)11543 static inline size_t vn_sizeof_vkGetDeviceQueue_reply(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
11544 {
11545 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT;
11546 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11547
11548 /* skip device */
11549 /* skip queueFamilyIndex */
11550 /* skip queueIndex */
11551 cmd_size += vn_sizeof_simple_pointer(pQueue);
11552 if (pQueue)
11553 cmd_size += vn_sizeof_VkQueue(pQueue);
11554
11555 return cmd_size;
11556 }
11557
vn_decode_vkGetDeviceQueue_reply(struct vn_cs_decoder * dec,VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)11558 static inline void vn_decode_vkGetDeviceQueue_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
11559 {
11560 VkCommandTypeEXT command_type;
11561 vn_decode_VkCommandTypeEXT(dec, &command_type);
11562 assert(command_type == VK_COMMAND_TYPE_vkGetDeviceQueue_EXT);
11563
11564 /* skip device */
11565 /* skip queueFamilyIndex */
11566 /* skip queueIndex */
11567 if (vn_decode_simple_pointer(dec)) {
11568 vn_decode_VkQueue(dec, pQueue);
11569 } else {
11570 pQueue = NULL;
11571 }
11572 }
11573
vn_sizeof_vkDeviceWaitIdle(VkDevice device)11574 static inline size_t vn_sizeof_vkDeviceWaitIdle(VkDevice device)
11575 {
11576 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT;
11577 const VkFlags cmd_flags = 0;
11578 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11579
11580 cmd_size += vn_sizeof_VkDevice(&device);
11581
11582 return cmd_size;
11583 }
11584
vn_encode_vkDeviceWaitIdle(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device)11585 static inline void vn_encode_vkDeviceWaitIdle(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device)
11586 {
11587 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT;
11588
11589 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11590 vn_encode_VkFlags(enc, &cmd_flags);
11591
11592 vn_encode_VkDevice(enc, &device);
11593 }
11594
vn_sizeof_vkDeviceWaitIdle_reply(VkDevice device)11595 static inline size_t vn_sizeof_vkDeviceWaitIdle_reply(VkDevice device)
11596 {
11597 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT;
11598 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11599
11600 VkResult ret;
11601 cmd_size += vn_sizeof_VkResult(&ret);
11602 /* skip device */
11603
11604 return cmd_size;
11605 }
11606
vn_decode_vkDeviceWaitIdle_reply(struct vn_cs_decoder * dec,VkDevice device)11607 static inline VkResult vn_decode_vkDeviceWaitIdle_reply(struct vn_cs_decoder *dec, VkDevice device)
11608 {
11609 VkCommandTypeEXT command_type;
11610 vn_decode_VkCommandTypeEXT(dec, &command_type);
11611 assert(command_type == VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT);
11612
11613 VkResult ret;
11614 vn_decode_VkResult(dec, &ret);
11615 /* skip device */
11616
11617 return ret;
11618 }
11619
vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)11620 static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
11621 {
11622 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT;
11623 const VkFlags cmd_flags = 0;
11624 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11625
11626 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11627 cmd_size += vn_sizeof_VkFormat(&format);
11628 cmd_size += vn_sizeof_VkImageType(&type);
11629 cmd_size += vn_sizeof_VkSampleCountFlagBits(&samples);
11630 cmd_size += vn_sizeof_VkFlags(&usage);
11631 cmd_size += vn_sizeof_VkImageTiling(&tiling);
11632 cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
11633 if (pPropertyCount)
11634 cmd_size += vn_sizeof_uint32_t(pPropertyCount);
11635 if (pProperties) {
11636 cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
11637 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
11638 cmd_size += vn_sizeof_VkSparseImageFormatProperties_partial(&pProperties[i]);
11639 } else {
11640 cmd_size += vn_sizeof_array_size(0);
11641 }
11642
11643 return cmd_size;
11644 }
11645
vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)11646 static inline void vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
11647 {
11648 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT;
11649
11650 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11651 vn_encode_VkFlags(enc, &cmd_flags);
11652
11653 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11654 vn_encode_VkFormat(enc, &format);
11655 vn_encode_VkImageType(enc, &type);
11656 vn_encode_VkSampleCountFlagBits(enc, &samples);
11657 vn_encode_VkFlags(enc, &usage);
11658 vn_encode_VkImageTiling(enc, &tiling);
11659 if (vn_encode_simple_pointer(enc, pPropertyCount))
11660 vn_encode_uint32_t(enc, pPropertyCount);
11661 if (pProperties) {
11662 vn_encode_array_size(enc, (pPropertyCount ? *pPropertyCount : 0));
11663 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
11664 vn_encode_VkSparseImageFormatProperties_partial(enc, &pProperties[i]);
11665 } else {
11666 vn_encode_array_size(enc, 0);
11667 }
11668 }
11669
vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties_reply(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)11670 static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
11671 {
11672 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT;
11673 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11674
11675 /* skip physicalDevice */
11676 /* skip format */
11677 /* skip type */
11678 /* skip samples */
11679 /* skip usage */
11680 /* skip tiling */
11681 cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
11682 if (pPropertyCount)
11683 cmd_size += vn_sizeof_uint32_t(pPropertyCount);
11684 if (pProperties) {
11685 cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
11686 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
11687 cmd_size += vn_sizeof_VkSparseImageFormatProperties(&pProperties[i]);
11688 } else {
11689 cmd_size += vn_sizeof_array_size(0);
11690 }
11691
11692 return cmd_size;
11693 }
11694
vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)11695 static inline void vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
11696 {
11697 VkCommandTypeEXT command_type;
11698 vn_decode_VkCommandTypeEXT(dec, &command_type);
11699 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT);
11700
11701 /* skip physicalDevice */
11702 /* skip format */
11703 /* skip type */
11704 /* skip samples */
11705 /* skip usage */
11706 /* skip tiling */
11707 if (vn_decode_simple_pointer(dec)) {
11708 vn_decode_uint32_t(dec, pPropertyCount);
11709 } else {
11710 pPropertyCount = NULL;
11711 }
11712 if (vn_peek_array_size(dec)) {
11713 const uint32_t iter_count = vn_decode_array_size(dec, (pPropertyCount ? *pPropertyCount : 0));
11714 for (uint32_t i = 0; i < iter_count; i++)
11715 vn_decode_VkSparseImageFormatProperties(dec, &pProperties[i]);
11716 } else {
11717 vn_decode_array_size_unchecked(dec);
11718 pProperties = NULL;
11719 }
11720 }
11721
vn_sizeof_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)11722 static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
11723 {
11724 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT;
11725 const VkFlags cmd_flags = 0;
11726 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11727
11728 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11729 cmd_size += vn_sizeof_simple_pointer(pFeatures);
11730 if (pFeatures)
11731 cmd_size += vn_sizeof_VkPhysicalDeviceFeatures2_partial(pFeatures);
11732
11733 return cmd_size;
11734 }
11735
vn_encode_vkGetPhysicalDeviceFeatures2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)11736 static inline void vn_encode_vkGetPhysicalDeviceFeatures2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
11737 {
11738 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT;
11739
11740 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11741 vn_encode_VkFlags(enc, &cmd_flags);
11742
11743 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11744 if (vn_encode_simple_pointer(enc, pFeatures))
11745 vn_encode_VkPhysicalDeviceFeatures2_partial(enc, pFeatures);
11746 }
11747
vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)11748 static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
11749 {
11750 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT;
11751 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11752
11753 /* skip physicalDevice */
11754 cmd_size += vn_sizeof_simple_pointer(pFeatures);
11755 if (pFeatures)
11756 cmd_size += vn_sizeof_VkPhysicalDeviceFeatures2(pFeatures);
11757
11758 return cmd_size;
11759 }
11760
vn_decode_vkGetPhysicalDeviceFeatures2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)11761 static inline void vn_decode_vkGetPhysicalDeviceFeatures2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
11762 {
11763 VkCommandTypeEXT command_type;
11764 vn_decode_VkCommandTypeEXT(dec, &command_type);
11765 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT);
11766
11767 /* skip physicalDevice */
11768 if (vn_decode_simple_pointer(dec)) {
11769 vn_decode_VkPhysicalDeviceFeatures2(dec, pFeatures);
11770 } else {
11771 pFeatures = NULL;
11772 }
11773 }
11774
vn_sizeof_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)11775 static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
11776 {
11777 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT;
11778 const VkFlags cmd_flags = 0;
11779 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11780
11781 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11782 cmd_size += vn_sizeof_simple_pointer(pProperties);
11783 if (pProperties)
11784 cmd_size += vn_sizeof_VkPhysicalDeviceProperties2_partial(pProperties);
11785
11786 return cmd_size;
11787 }
11788
vn_encode_vkGetPhysicalDeviceProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)11789 static inline void vn_encode_vkGetPhysicalDeviceProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
11790 {
11791 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT;
11792
11793 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11794 vn_encode_VkFlags(enc, &cmd_flags);
11795
11796 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11797 if (vn_encode_simple_pointer(enc, pProperties))
11798 vn_encode_VkPhysicalDeviceProperties2_partial(enc, pProperties);
11799 }
11800
vn_sizeof_vkGetPhysicalDeviceProperties2_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)11801 static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
11802 {
11803 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT;
11804 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11805
11806 /* skip physicalDevice */
11807 cmd_size += vn_sizeof_simple_pointer(pProperties);
11808 if (pProperties)
11809 cmd_size += vn_sizeof_VkPhysicalDeviceProperties2(pProperties);
11810
11811 return cmd_size;
11812 }
11813
vn_decode_vkGetPhysicalDeviceProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)11814 static inline void vn_decode_vkGetPhysicalDeviceProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
11815 {
11816 VkCommandTypeEXT command_type;
11817 vn_decode_VkCommandTypeEXT(dec, &command_type);
11818 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT);
11819
11820 /* skip physicalDevice */
11821 if (vn_decode_simple_pointer(dec)) {
11822 vn_decode_VkPhysicalDeviceProperties2(dec, pProperties);
11823 } else {
11824 pProperties = NULL;
11825 }
11826 }
11827
vn_sizeof_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)11828 static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
11829 {
11830 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT;
11831 const VkFlags cmd_flags = 0;
11832 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11833
11834 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11835 cmd_size += vn_sizeof_VkFormat(&format);
11836 cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
11837 if (pFormatProperties)
11838 cmd_size += vn_sizeof_VkFormatProperties2_partial(pFormatProperties);
11839
11840 return cmd_size;
11841 }
11842
vn_encode_vkGetPhysicalDeviceFormatProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)11843 static inline void vn_encode_vkGetPhysicalDeviceFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
11844 {
11845 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT;
11846
11847 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11848 vn_encode_VkFlags(enc, &cmd_flags);
11849
11850 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11851 vn_encode_VkFormat(enc, &format);
11852 if (vn_encode_simple_pointer(enc, pFormatProperties))
11853 vn_encode_VkFormatProperties2_partial(enc, pFormatProperties);
11854 }
11855
vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)11856 static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
11857 {
11858 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT;
11859 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11860
11861 /* skip physicalDevice */
11862 /* skip format */
11863 cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
11864 if (pFormatProperties)
11865 cmd_size += vn_sizeof_VkFormatProperties2(pFormatProperties);
11866
11867 return cmd_size;
11868 }
11869
vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)11870 static inline void vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
11871 {
11872 VkCommandTypeEXT command_type;
11873 vn_decode_VkCommandTypeEXT(dec, &command_type);
11874 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT);
11875
11876 /* skip physicalDevice */
11877 /* skip format */
11878 if (vn_decode_simple_pointer(dec)) {
11879 vn_decode_VkFormatProperties2(dec, pFormatProperties);
11880 } else {
11881 pFormatProperties = NULL;
11882 }
11883 }
11884
vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)11885 static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
11886 {
11887 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT;
11888 const VkFlags cmd_flags = 0;
11889 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11890
11891 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11892 cmd_size += vn_sizeof_simple_pointer(pImageFormatInfo);
11893 if (pImageFormatInfo)
11894 cmd_size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2(pImageFormatInfo);
11895 cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
11896 if (pImageFormatProperties)
11897 cmd_size += vn_sizeof_VkImageFormatProperties2_partial(pImageFormatProperties);
11898
11899 return cmd_size;
11900 }
11901
vn_encode_vkGetPhysicalDeviceImageFormatProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)11902 static inline void vn_encode_vkGetPhysicalDeviceImageFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
11903 {
11904 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT;
11905
11906 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11907 vn_encode_VkFlags(enc, &cmd_flags);
11908
11909 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11910 if (vn_encode_simple_pointer(enc, pImageFormatInfo))
11911 vn_encode_VkPhysicalDeviceImageFormatInfo2(enc, pImageFormatInfo);
11912 if (vn_encode_simple_pointer(enc, pImageFormatProperties))
11913 vn_encode_VkImageFormatProperties2_partial(enc, pImageFormatProperties);
11914 }
11915
vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)11916 static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
11917 {
11918 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT;
11919 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11920
11921 VkResult ret;
11922 cmd_size += vn_sizeof_VkResult(&ret);
11923 /* skip physicalDevice */
11924 /* skip pImageFormatInfo */
11925 cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
11926 if (pImageFormatProperties)
11927 cmd_size += vn_sizeof_VkImageFormatProperties2(pImageFormatProperties);
11928
11929 return cmd_size;
11930 }
11931
vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)11932 static inline VkResult vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
11933 {
11934 VkCommandTypeEXT command_type;
11935 vn_decode_VkCommandTypeEXT(dec, &command_type);
11936 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT);
11937
11938 VkResult ret;
11939 vn_decode_VkResult(dec, &ret);
11940 /* skip physicalDevice */
11941 /* skip pImageFormatInfo */
11942 if (vn_decode_simple_pointer(dec)) {
11943 vn_decode_VkImageFormatProperties2(dec, pImageFormatProperties);
11944 } else {
11945 pImageFormatProperties = NULL;
11946 }
11947
11948 return ret;
11949 }
11950
vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)11951 static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
11952 {
11953 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT;
11954 const VkFlags cmd_flags = 0;
11955 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11956
11957 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11958 cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
11959 if (pQueueFamilyPropertyCount)
11960 cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
11961 if (pQueueFamilyProperties) {
11962 cmd_size += vn_sizeof_array_size((pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
11963 for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
11964 cmd_size += vn_sizeof_VkQueueFamilyProperties2_partial(&pQueueFamilyProperties[i]);
11965 } else {
11966 cmd_size += vn_sizeof_array_size(0);
11967 }
11968
11969 return cmd_size;
11970 }
11971
vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)11972 static inline void vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
11973 {
11974 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT;
11975
11976 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11977 vn_encode_VkFlags(enc, &cmd_flags);
11978
11979 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11980 if (vn_encode_simple_pointer(enc, pQueueFamilyPropertyCount))
11981 vn_encode_uint32_t(enc, pQueueFamilyPropertyCount);
11982 if (pQueueFamilyProperties) {
11983 vn_encode_array_size(enc, (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
11984 for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
11985 vn_encode_VkQueueFamilyProperties2_partial(enc, &pQueueFamilyProperties[i]);
11986 } else {
11987 vn_encode_array_size(enc, 0);
11988 }
11989 }
11990
vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)11991 static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
11992 {
11993 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT;
11994 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11995
11996 /* skip physicalDevice */
11997 cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
11998 if (pQueueFamilyPropertyCount)
11999 cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
12000 if (pQueueFamilyProperties) {
12001 cmd_size += vn_sizeof_array_size((pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
12002 for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
12003 cmd_size += vn_sizeof_VkQueueFamilyProperties2(&pQueueFamilyProperties[i]);
12004 } else {
12005 cmd_size += vn_sizeof_array_size(0);
12006 }
12007
12008 return cmd_size;
12009 }
12010
vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)12011 static inline void vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
12012 {
12013 VkCommandTypeEXT command_type;
12014 vn_decode_VkCommandTypeEXT(dec, &command_type);
12015 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT);
12016
12017 /* skip physicalDevice */
12018 if (vn_decode_simple_pointer(dec)) {
12019 vn_decode_uint32_t(dec, pQueueFamilyPropertyCount);
12020 } else {
12021 pQueueFamilyPropertyCount = NULL;
12022 }
12023 if (vn_peek_array_size(dec)) {
12024 const uint32_t iter_count = vn_decode_array_size(dec, (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
12025 for (uint32_t i = 0; i < iter_count; i++)
12026 vn_decode_VkQueueFamilyProperties2(dec, &pQueueFamilyProperties[i]);
12027 } else {
12028 vn_decode_array_size_unchecked(dec);
12029 pQueueFamilyProperties = NULL;
12030 }
12031 }
12032
vn_sizeof_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)12033 static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
12034 {
12035 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT;
12036 const VkFlags cmd_flags = 0;
12037 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
12038
12039 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
12040 cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
12041 if (pMemoryProperties)
12042 cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_partial(pMemoryProperties);
12043
12044 return cmd_size;
12045 }
12046
vn_encode_vkGetPhysicalDeviceMemoryProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)12047 static inline void vn_encode_vkGetPhysicalDeviceMemoryProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
12048 {
12049 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT;
12050
12051 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
12052 vn_encode_VkFlags(enc, &cmd_flags);
12053
12054 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
12055 if (vn_encode_simple_pointer(enc, pMemoryProperties))
12056 vn_encode_VkPhysicalDeviceMemoryProperties2_partial(enc, pMemoryProperties);
12057 }
12058
vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)12059 static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
12060 {
12061 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT;
12062 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
12063
12064 /* skip physicalDevice */
12065 cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
12066 if (pMemoryProperties)
12067 cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties2(pMemoryProperties);
12068
12069 return cmd_size;
12070 }
12071
vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)12072 static inline void vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
12073 {
12074 VkCommandTypeEXT command_type;
12075 vn_decode_VkCommandTypeEXT(dec, &command_type);
12076 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT);
12077
12078 /* skip physicalDevice */
12079 if (vn_decode_simple_pointer(dec)) {
12080 vn_decode_VkPhysicalDeviceMemoryProperties2(dec, pMemoryProperties);
12081 } else {
12082 pMemoryProperties = NULL;
12083 }
12084 }
12085
vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)12086 static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
12087 {
12088 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT;
12089 const VkFlags cmd_flags = 0;
12090 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
12091
12092 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
12093 cmd_size += vn_sizeof_simple_pointer(pFormatInfo);
12094 if (pFormatInfo)
12095 cmd_size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2(pFormatInfo);
12096 cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
12097 if (pPropertyCount)
12098 cmd_size += vn_sizeof_uint32_t(pPropertyCount);
12099 if (pProperties) {
12100 cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
12101 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
12102 cmd_size += vn_sizeof_VkSparseImageFormatProperties2_partial(&pProperties[i]);
12103 } else {
12104 cmd_size += vn_sizeof_array_size(0);
12105 }
12106
12107 return cmd_size;
12108 }
12109
vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)12110 static inline void vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
12111 {
12112 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT;
12113
12114 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
12115 vn_encode_VkFlags(enc, &cmd_flags);
12116
12117 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
12118 if (vn_encode_simple_pointer(enc, pFormatInfo))
12119 vn_encode_VkPhysicalDeviceSparseImageFormatInfo2(enc, pFormatInfo);
12120 if (vn_encode_simple_pointer(enc, pPropertyCount))
12121 vn_encode_uint32_t(enc, pPropertyCount);
12122 if (pProperties) {
12123 vn_encode_array_size(enc, (pPropertyCount ? *pPropertyCount : 0));
12124 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
12125 vn_encode_VkSparseImageFormatProperties2_partial(enc, &pProperties[i]);
12126 } else {
12127 vn_encode_array_size(enc, 0);
12128 }
12129 }
12130
vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)12131 static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
12132 {
12133 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT;
12134 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
12135
12136 /* skip physicalDevice */
12137 /* skip pFormatInfo */
12138 cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
12139 if (pPropertyCount)
12140 cmd_size += vn_sizeof_uint32_t(pPropertyCount);
12141 if (pProperties) {
12142 cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
12143 for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
12144 cmd_size += vn_sizeof_VkSparseImageFormatProperties2(&pProperties[i]);
12145 } else {
12146 cmd_size += vn_sizeof_array_size(0);
12147 }
12148
12149 return cmd_size;
12150 }
12151
vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)12152 static inline void vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
12153 {
12154 VkCommandTypeEXT command_type;
12155 vn_decode_VkCommandTypeEXT(dec, &command_type);
12156 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT);
12157
12158 /* skip physicalDevice */
12159 /* skip pFormatInfo */
12160 if (vn_decode_simple_pointer(dec)) {
12161 vn_decode_uint32_t(dec, pPropertyCount);
12162 } else {
12163 pPropertyCount = NULL;
12164 }
12165 if (vn_peek_array_size(dec)) {
12166 const uint32_t iter_count = vn_decode_array_size(dec, (pPropertyCount ? *pPropertyCount : 0));
12167 for (uint32_t i = 0; i < iter_count; i++)
12168 vn_decode_VkSparseImageFormatProperties2(dec, &pProperties[i]);
12169 } else {
12170 vn_decode_array_size_unchecked(dec);
12171 pProperties = NULL;
12172 }
12173 }
12174
vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)12175 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
12176 {
12177 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT;
12178 const VkFlags cmd_flags = 0;
12179 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
12180
12181 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
12182 cmd_size += vn_sizeof_simple_pointer(pExternalBufferInfo);
12183 if (pExternalBufferInfo)
12184 cmd_size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo(pExternalBufferInfo);
12185 cmd_size += vn_sizeof_simple_pointer(pExternalBufferProperties);
12186 if (pExternalBufferProperties)
12187 cmd_size += vn_sizeof_VkExternalBufferProperties_partial(pExternalBufferProperties);
12188
12189 return cmd_size;
12190 }
12191
vn_encode_vkGetPhysicalDeviceExternalBufferProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)12192 static inline void vn_encode_vkGetPhysicalDeviceExternalBufferProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
12193 {
12194 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT;
12195
12196 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
12197 vn_encode_VkFlags(enc, &cmd_flags);
12198
12199 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
12200 if (vn_encode_simple_pointer(enc, pExternalBufferInfo))
12201 vn_encode_VkPhysicalDeviceExternalBufferInfo(enc, pExternalBufferInfo);
12202 if (vn_encode_simple_pointer(enc, pExternalBufferProperties))
12203 vn_encode_VkExternalBufferProperties_partial(enc, pExternalBufferProperties);
12204 }
12205
vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)12206 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
12207 {
12208 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT;
12209 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
12210
12211 /* skip physicalDevice */
12212 /* skip pExternalBufferInfo */
12213 cmd_size += vn_sizeof_simple_pointer(pExternalBufferProperties);
12214 if (pExternalBufferProperties)
12215 cmd_size += vn_sizeof_VkExternalBufferProperties(pExternalBufferProperties);
12216
12217 return cmd_size;
12218 }
12219
vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)12220 static inline void vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
12221 {
12222 VkCommandTypeEXT command_type;
12223 vn_decode_VkCommandTypeEXT(dec, &command_type);
12224 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT);
12225
12226 /* skip physicalDevice */
12227 /* skip pExternalBufferInfo */
12228 if (vn_decode_simple_pointer(dec)) {
12229 vn_decode_VkExternalBufferProperties(dec, pExternalBufferProperties);
12230 } else {
12231 pExternalBufferProperties = NULL;
12232 }
12233 }
12234
vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)12235 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
12236 {
12237 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT;
12238 const VkFlags cmd_flags = 0;
12239 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
12240
12241 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
12242 cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreInfo);
12243 if (pExternalSemaphoreInfo)
12244 cmd_size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo(pExternalSemaphoreInfo);
12245 cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreProperties);
12246 if (pExternalSemaphoreProperties)
12247 cmd_size += vn_sizeof_VkExternalSemaphoreProperties_partial(pExternalSemaphoreProperties);
12248
12249 return cmd_size;
12250 }
12251
vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)12252 static inline void vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
12253 {
12254 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT;
12255
12256 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
12257 vn_encode_VkFlags(enc, &cmd_flags);
12258
12259 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
12260 if (vn_encode_simple_pointer(enc, pExternalSemaphoreInfo))
12261 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo(enc, pExternalSemaphoreInfo);
12262 if (vn_encode_simple_pointer(enc, pExternalSemaphoreProperties))
12263 vn_encode_VkExternalSemaphoreProperties_partial(enc, pExternalSemaphoreProperties);
12264 }
12265
vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)12266 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
12267 {
12268 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT;
12269 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
12270
12271 /* skip physicalDevice */
12272 /* skip pExternalSemaphoreInfo */
12273 cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreProperties);
12274 if (pExternalSemaphoreProperties)
12275 cmd_size += vn_sizeof_VkExternalSemaphoreProperties(pExternalSemaphoreProperties);
12276
12277 return cmd_size;
12278 }
12279
vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)12280 static inline void vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
12281 {
12282 VkCommandTypeEXT command_type;
12283 vn_decode_VkCommandTypeEXT(dec, &command_type);
12284 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT);
12285
12286 /* skip physicalDevice */
12287 /* skip pExternalSemaphoreInfo */
12288 if (vn_decode_simple_pointer(dec)) {
12289 vn_decode_VkExternalSemaphoreProperties(dec, pExternalSemaphoreProperties);
12290 } else {
12291 pExternalSemaphoreProperties = NULL;
12292 }
12293 }
12294
vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)12295 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
12296 {
12297 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT;
12298 const VkFlags cmd_flags = 0;
12299 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
12300
12301 cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
12302 cmd_size += vn_sizeof_simple_pointer(pExternalFenceInfo);
12303 if (pExternalFenceInfo)
12304 cmd_size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo(pExternalFenceInfo);
12305 cmd_size += vn_sizeof_simple_pointer(pExternalFenceProperties);
12306 if (pExternalFenceProperties)
12307 cmd_size += vn_sizeof_VkExternalFenceProperties_partial(pExternalFenceProperties);
12308
12309 return cmd_size;
12310 }
12311
vn_encode_vkGetPhysicalDeviceExternalFenceProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)12312 static inline void vn_encode_vkGetPhysicalDeviceExternalFenceProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
12313 {
12314 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT;
12315
12316 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
12317 vn_encode_VkFlags(enc, &cmd_flags);
12318
12319 vn_encode_VkPhysicalDevice(enc, &physicalDevice);
12320 if (vn_encode_simple_pointer(enc, pExternalFenceInfo))
12321 vn_encode_VkPhysicalDeviceExternalFenceInfo(enc, pExternalFenceInfo);
12322 if (vn_encode_simple_pointer(enc, pExternalFenceProperties))
12323 vn_encode_VkExternalFenceProperties_partial(enc, pExternalFenceProperties);
12324 }
12325
vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)12326 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
12327 {
12328 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT;
12329 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
12330
12331 /* skip physicalDevice */
12332 /* skip pExternalFenceInfo */
12333 cmd_size += vn_sizeof_simple_pointer(pExternalFenceProperties);
12334 if (pExternalFenceProperties)
12335 cmd_size += vn_sizeof_VkExternalFenceProperties(pExternalFenceProperties);
12336
12337 return cmd_size;
12338 }
12339
vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)12340 static inline void vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
12341 {
12342 VkCommandTypeEXT command_type;
12343 vn_decode_VkCommandTypeEXT(dec, &command_type);
12344 assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT);
12345
12346 /* skip physicalDevice */
12347 /* skip pExternalFenceInfo */
12348 if (vn_decode_simple_pointer(dec)) {
12349 vn_decode_VkExternalFenceProperties(dec, pExternalFenceProperties);
12350 } else {
12351 pExternalFenceProperties = NULL;
12352 }
12353 }
12354
vn_sizeof_vkEnumeratePhysicalDeviceGroups(VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)12355 static inline size_t vn_sizeof_vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
12356 {
12357 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT;
12358 const VkFlags cmd_flags = 0;
12359 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
12360
12361 cmd_size += vn_sizeof_VkInstance(&instance);
12362 cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceGroupCount);
12363 if (pPhysicalDeviceGroupCount)
12364 cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceGroupCount);
12365 if (pPhysicalDeviceGroupProperties) {
12366 cmd_size += vn_sizeof_array_size((pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0));
12367 for (uint32_t i = 0; i < (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0); i++)
12368 cmd_size += vn_sizeof_VkPhysicalDeviceGroupProperties_partial(&pPhysicalDeviceGroupProperties[i]);
12369 } else {
12370 cmd_size += vn_sizeof_array_size(0);
12371 }
12372
12373 return cmd_size;
12374 }
12375
vn_encode_vkEnumeratePhysicalDeviceGroups(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)12376 static inline void vn_encode_vkEnumeratePhysicalDeviceGroups(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
12377 {
12378 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT;
12379
12380 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
12381 vn_encode_VkFlags(enc, &cmd_flags);
12382
12383 vn_encode_VkInstance(enc, &instance);
12384 if (vn_encode_simple_pointer(enc, pPhysicalDeviceGroupCount))
12385 vn_encode_uint32_t(enc, pPhysicalDeviceGroupCount);
12386 if (pPhysicalDeviceGroupProperties) {
12387 vn_encode_array_size(enc, (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0));
12388 for (uint32_t i = 0; i < (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0); i++)
12389 vn_encode_VkPhysicalDeviceGroupProperties_partial(enc, &pPhysicalDeviceGroupProperties[i]);
12390 } else {
12391 vn_encode_array_size(enc, 0);
12392 }
12393 }
12394
vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)12395 static inline size_t vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
12396 {
12397 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT;
12398 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
12399
12400 VkResult ret;
12401 cmd_size += vn_sizeof_VkResult(&ret);
12402 /* skip instance */
12403 cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceGroupCount);
12404 if (pPhysicalDeviceGroupCount)
12405 cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceGroupCount);
12406 if (pPhysicalDeviceGroupProperties) {
12407 cmd_size += vn_sizeof_array_size((pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0));
12408 for (uint32_t i = 0; i < (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0); i++)
12409 cmd_size += vn_sizeof_VkPhysicalDeviceGroupProperties(&pPhysicalDeviceGroupProperties[i]);
12410 } else {
12411 cmd_size += vn_sizeof_array_size(0);
12412 }
12413
12414 return cmd_size;
12415 }
12416
vn_decode_vkEnumeratePhysicalDeviceGroups_reply(struct vn_cs_decoder * dec,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)12417 static inline VkResult vn_decode_vkEnumeratePhysicalDeviceGroups_reply(struct vn_cs_decoder *dec, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
12418 {
12419 VkCommandTypeEXT command_type;
12420 vn_decode_VkCommandTypeEXT(dec, &command_type);
12421 assert(command_type == VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT);
12422
12423 VkResult ret;
12424 vn_decode_VkResult(dec, &ret);
12425 /* skip instance */
12426 if (vn_decode_simple_pointer(dec)) {
12427 vn_decode_uint32_t(dec, pPhysicalDeviceGroupCount);
12428 } else {
12429 pPhysicalDeviceGroupCount = NULL;
12430 }
12431 if (vn_peek_array_size(dec)) {
12432 const uint32_t iter_count = vn_decode_array_size(dec, (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0));
12433 for (uint32_t i = 0; i < iter_count; i++)
12434 vn_decode_VkPhysicalDeviceGroupProperties(dec, &pPhysicalDeviceGroupProperties[i]);
12435 } else {
12436 vn_decode_array_size_unchecked(dec);
12437 pPhysicalDeviceGroupProperties = NULL;
12438 }
12439
12440 return ret;
12441 }
12442
vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)12443 static inline size_t vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
12444 {
12445 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT;
12446 const VkFlags cmd_flags = 0;
12447 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
12448
12449 cmd_size += vn_sizeof_VkDevice(&device);
12450 cmd_size += vn_sizeof_uint32_t(&heapIndex);
12451 cmd_size += vn_sizeof_uint32_t(&localDeviceIndex);
12452 cmd_size += vn_sizeof_uint32_t(&remoteDeviceIndex);
12453 cmd_size += vn_sizeof_simple_pointer(pPeerMemoryFeatures); /* out */
12454
12455 return cmd_size;
12456 }
12457
vn_encode_vkGetDeviceGroupPeerMemoryFeatures(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)12458 static inline void vn_encode_vkGetDeviceGroupPeerMemoryFeatures(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
12459 {
12460 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT;
12461
12462 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
12463 vn_encode_VkFlags(enc, &cmd_flags);
12464
12465 vn_encode_VkDevice(enc, &device);
12466 vn_encode_uint32_t(enc, &heapIndex);
12467 vn_encode_uint32_t(enc, &localDeviceIndex);
12468 vn_encode_uint32_t(enc, &remoteDeviceIndex);
12469 vn_encode_simple_pointer(enc, pPeerMemoryFeatures); /* out */
12470 }
12471
vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)12472 static inline size_t vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
12473 {
12474 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT;
12475 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
12476
12477 /* skip device */
12478 /* skip heapIndex */
12479 /* skip localDeviceIndex */
12480 /* skip remoteDeviceIndex */
12481 cmd_size += vn_sizeof_simple_pointer(pPeerMemoryFeatures);
12482 if (pPeerMemoryFeatures)
12483 cmd_size += vn_sizeof_VkFlags(pPeerMemoryFeatures);
12484
12485 return cmd_size;
12486 }
12487
vn_decode_vkGetDeviceGroupPeerMemoryFeatures_reply(struct vn_cs_decoder * dec,VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)12488 static inline void vn_decode_vkGetDeviceGroupPeerMemoryFeatures_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
12489 {
12490 VkCommandTypeEXT command_type;
12491 vn_decode_VkCommandTypeEXT(dec, &command_type);
12492 assert(command_type == VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT);
12493
12494 /* skip device */
12495 /* skip heapIndex */
12496 /* skip localDeviceIndex */
12497 /* skip remoteDeviceIndex */
12498 if (vn_decode_simple_pointer(dec)) {
12499 vn_decode_VkFlags(dec, pPeerMemoryFeatures);
12500 } else {
12501 pPeerMemoryFeatures = NULL;
12502 }
12503 }
12504
vn_sizeof_vkGetDeviceQueue2(VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)12505 static inline size_t vn_sizeof_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
12506 {
12507 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT;
12508 const VkFlags cmd_flags = 0;
12509 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
12510
12511 cmd_size += vn_sizeof_VkDevice(&device);
12512 cmd_size += vn_sizeof_simple_pointer(pQueueInfo);
12513 if (pQueueInfo)
12514 cmd_size += vn_sizeof_VkDeviceQueueInfo2(pQueueInfo);
12515 cmd_size += vn_sizeof_simple_pointer(pQueue);
12516 if (pQueue)
12517 cmd_size += vn_sizeof_VkQueue(pQueue);
12518
12519 return cmd_size;
12520 }
12521
vn_encode_vkGetDeviceQueue2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)12522 static inline void vn_encode_vkGetDeviceQueue2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
12523 {
12524 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT;
12525
12526 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
12527 vn_encode_VkFlags(enc, &cmd_flags);
12528
12529 vn_encode_VkDevice(enc, &device);
12530 if (vn_encode_simple_pointer(enc, pQueueInfo))
12531 vn_encode_VkDeviceQueueInfo2(enc, pQueueInfo);
12532 if (vn_encode_simple_pointer(enc, pQueue))
12533 vn_encode_VkQueue(enc, pQueue);
12534 }
12535
vn_sizeof_vkGetDeviceQueue2_reply(VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)12536 static inline size_t vn_sizeof_vkGetDeviceQueue2_reply(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
12537 {
12538 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT;
12539 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
12540
12541 /* skip device */
12542 /* skip pQueueInfo */
12543 cmd_size += vn_sizeof_simple_pointer(pQueue);
12544 if (pQueue)
12545 cmd_size += vn_sizeof_VkQueue(pQueue);
12546
12547 return cmd_size;
12548 }
12549
vn_decode_vkGetDeviceQueue2_reply(struct vn_cs_decoder * dec,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)12550 static inline void vn_decode_vkGetDeviceQueue2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
12551 {
12552 VkCommandTypeEXT command_type;
12553 vn_decode_VkCommandTypeEXT(dec, &command_type);
12554 assert(command_type == VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT);
12555
12556 /* skip device */
12557 /* skip pQueueInfo */
12558 if (vn_decode_simple_pointer(dec)) {
12559 vn_decode_VkQueue(dec, pQueue);
12560 } else {
12561 pQueue = NULL;
12562 }
12563 }
12564
vn_submit_vkEnumeratePhysicalDevices(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices,struct vn_instance_submit_command * submit)12565 static inline void vn_submit_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices, struct vn_instance_submit_command *submit)
12566 {
12567 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12568 void *cmd_data = local_cmd_data;
12569 size_t cmd_size = vn_sizeof_vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
12570 if (cmd_size > sizeof(local_cmd_data)) {
12571 cmd_data = malloc(cmd_size);
12572 if (!cmd_data)
12573 cmd_size = 0;
12574 }
12575 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumeratePhysicalDevices_reply(instance, pPhysicalDeviceCount, pPhysicalDevices) : 0;
12576
12577 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12578 if (cmd_size) {
12579 vn_encode_vkEnumeratePhysicalDevices(enc, cmd_flags, instance, pPhysicalDeviceCount, pPhysicalDevices);
12580 vn_instance_submit_command(vn_instance, submit);
12581 if (cmd_data != local_cmd_data)
12582 free(cmd_data);
12583 }
12584 }
12585
vn_submit_vkGetPhysicalDeviceProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties,struct vn_instance_submit_command * submit)12586 static inline void vn_submit_vkGetPhysicalDeviceProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties, struct vn_instance_submit_command *submit)
12587 {
12588 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12589 void *cmd_data = local_cmd_data;
12590 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceProperties(physicalDevice, pProperties);
12591 if (cmd_size > sizeof(local_cmd_data)) {
12592 cmd_data = malloc(cmd_size);
12593 if (!cmd_data)
12594 cmd_size = 0;
12595 }
12596 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceProperties_reply(physicalDevice, pProperties) : 0;
12597
12598 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12599 if (cmd_size) {
12600 vn_encode_vkGetPhysicalDeviceProperties(enc, cmd_flags, physicalDevice, pProperties);
12601 vn_instance_submit_command(vn_instance, submit);
12602 if (cmd_data != local_cmd_data)
12603 free(cmd_data);
12604 }
12605 }
12606
vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties,struct vn_instance_submit_command * submit)12607 static inline void vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties, struct vn_instance_submit_command *submit)
12608 {
12609 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12610 void *cmd_data = local_cmd_data;
12611 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
12612 if (cmd_size > sizeof(local_cmd_data)) {
12613 cmd_data = malloc(cmd_size);
12614 if (!cmd_data)
12615 cmd_size = 0;
12616 }
12617 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) : 0;
12618
12619 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12620 if (cmd_size) {
12621 vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(enc, cmd_flags, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
12622 vn_instance_submit_command(vn_instance, submit);
12623 if (cmd_data != local_cmd_data)
12624 free(cmd_data);
12625 }
12626 }
12627
vn_submit_vkGetPhysicalDeviceMemoryProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties,struct vn_instance_submit_command * submit)12628 static inline void vn_submit_vkGetPhysicalDeviceMemoryProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties, struct vn_instance_submit_command *submit)
12629 {
12630 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12631 void *cmd_data = local_cmd_data;
12632 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
12633 if (cmd_size > sizeof(local_cmd_data)) {
12634 cmd_data = malloc(cmd_size);
12635 if (!cmd_data)
12636 cmd_size = 0;
12637 }
12638 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(physicalDevice, pMemoryProperties) : 0;
12639
12640 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12641 if (cmd_size) {
12642 vn_encode_vkGetPhysicalDeviceMemoryProperties(enc, cmd_flags, physicalDevice, pMemoryProperties);
12643 vn_instance_submit_command(vn_instance, submit);
12644 if (cmd_data != local_cmd_data)
12645 free(cmd_data);
12646 }
12647 }
12648
vn_submit_vkGetPhysicalDeviceFeatures(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures,struct vn_instance_submit_command * submit)12649 static inline void vn_submit_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures, struct vn_instance_submit_command *submit)
12650 {
12651 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12652 void *cmd_data = local_cmd_data;
12653 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
12654 if (cmd_size > sizeof(local_cmd_data)) {
12655 cmd_data = malloc(cmd_size);
12656 if (!cmd_data)
12657 cmd_size = 0;
12658 }
12659 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFeatures_reply(physicalDevice, pFeatures) : 0;
12660
12661 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12662 if (cmd_size) {
12663 vn_encode_vkGetPhysicalDeviceFeatures(enc, cmd_flags, physicalDevice, pFeatures);
12664 vn_instance_submit_command(vn_instance, submit);
12665 if (cmd_data != local_cmd_data)
12666 free(cmd_data);
12667 }
12668 }
12669
vn_submit_vkGetPhysicalDeviceFormatProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties,struct vn_instance_submit_command * submit)12670 static inline void vn_submit_vkGetPhysicalDeviceFormatProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties, struct vn_instance_submit_command *submit)
12671 {
12672 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12673 void *cmd_data = local_cmd_data;
12674 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
12675 if (cmd_size > sizeof(local_cmd_data)) {
12676 cmd_data = malloc(cmd_size);
12677 if (!cmd_data)
12678 cmd_size = 0;
12679 }
12680 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(physicalDevice, format, pFormatProperties) : 0;
12681
12682 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12683 if (cmd_size) {
12684 vn_encode_vkGetPhysicalDeviceFormatProperties(enc, cmd_flags, physicalDevice, format, pFormatProperties);
12685 vn_instance_submit_command(vn_instance, submit);
12686 if (cmd_data != local_cmd_data)
12687 free(cmd_data);
12688 }
12689 }
12690
vn_submit_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties,struct vn_instance_submit_command * submit)12691 static inline void vn_submit_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties, struct vn_instance_submit_command *submit)
12692 {
12693 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12694 void *cmd_data = local_cmd_data;
12695 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
12696 if (cmd_size > sizeof(local_cmd_data)) {
12697 cmd_data = malloc(cmd_size);
12698 if (!cmd_data)
12699 cmd_size = 0;
12700 }
12701 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceImageFormatProperties_reply(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties) : 0;
12702
12703 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12704 if (cmd_size) {
12705 vn_encode_vkGetPhysicalDeviceImageFormatProperties(enc, cmd_flags, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
12706 vn_instance_submit_command(vn_instance, submit);
12707 if (cmd_data != local_cmd_data)
12708 free(cmd_data);
12709 }
12710 }
12711
vn_submit_vkCreateDevice(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice,struct vn_instance_submit_command * submit)12712 static inline void vn_submit_vkCreateDevice(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, struct vn_instance_submit_command *submit)
12713 {
12714 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12715 void *cmd_data = local_cmd_data;
12716 size_t cmd_size = vn_sizeof_vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
12717 if (cmd_size > sizeof(local_cmd_data)) {
12718 cmd_data = malloc(cmd_size);
12719 if (!cmd_data)
12720 cmd_size = 0;
12721 }
12722 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDevice_reply(physicalDevice, pCreateInfo, pAllocator, pDevice) : 0;
12723
12724 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12725 if (cmd_size) {
12726 vn_encode_vkCreateDevice(enc, cmd_flags, physicalDevice, pCreateInfo, pAllocator, pDevice);
12727 vn_instance_submit_command(vn_instance, submit);
12728 if (cmd_data != local_cmd_data)
12729 free(cmd_data);
12730 }
12731 }
12732
vn_submit_vkDestroyDevice(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkAllocationCallbacks * pAllocator,struct vn_instance_submit_command * submit)12733 static inline void vn_submit_vkDestroyDevice(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
12734 {
12735 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12736 void *cmd_data = local_cmd_data;
12737 size_t cmd_size = vn_sizeof_vkDestroyDevice(device, pAllocator);
12738 if (cmd_size > sizeof(local_cmd_data)) {
12739 cmd_data = malloc(cmd_size);
12740 if (!cmd_data)
12741 cmd_size = 0;
12742 }
12743 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDevice_reply(device, pAllocator) : 0;
12744
12745 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12746 if (cmd_size) {
12747 vn_encode_vkDestroyDevice(enc, cmd_flags, device, pAllocator);
12748 vn_instance_submit_command(vn_instance, submit);
12749 if (cmd_data != local_cmd_data)
12750 free(cmd_data);
12751 }
12752 }
12753
vn_submit_vkEnumerateDeviceLayerProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties,struct vn_instance_submit_command * submit)12754 static inline void vn_submit_vkEnumerateDeviceLayerProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties, struct vn_instance_submit_command *submit)
12755 {
12756 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12757 void *cmd_data = local_cmd_data;
12758 size_t cmd_size = vn_sizeof_vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
12759 if (cmd_size > sizeof(local_cmd_data)) {
12760 cmd_data = malloc(cmd_size);
12761 if (!cmd_data)
12762 cmd_size = 0;
12763 }
12764 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateDeviceLayerProperties_reply(physicalDevice, pPropertyCount, pProperties) : 0;
12765
12766 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12767 if (cmd_size) {
12768 vn_encode_vkEnumerateDeviceLayerProperties(enc, cmd_flags, physicalDevice, pPropertyCount, pProperties);
12769 vn_instance_submit_command(vn_instance, submit);
12770 if (cmd_data != local_cmd_data)
12771 free(cmd_data);
12772 }
12773 }
12774
vn_submit_vkEnumerateDeviceExtensionProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties,struct vn_instance_submit_command * submit)12775 static inline void vn_submit_vkEnumerateDeviceExtensionProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, struct vn_instance_submit_command *submit)
12776 {
12777 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12778 void *cmd_data = local_cmd_data;
12779 size_t cmd_size = vn_sizeof_vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
12780 if (cmd_size > sizeof(local_cmd_data)) {
12781 cmd_data = malloc(cmd_size);
12782 if (!cmd_data)
12783 cmd_size = 0;
12784 }
12785 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(physicalDevice, pLayerName, pPropertyCount, pProperties) : 0;
12786
12787 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12788 if (cmd_size) {
12789 vn_encode_vkEnumerateDeviceExtensionProperties(enc, cmd_flags, physicalDevice, pLayerName, pPropertyCount, pProperties);
12790 vn_instance_submit_command(vn_instance, submit);
12791 if (cmd_data != local_cmd_data)
12792 free(cmd_data);
12793 }
12794 }
12795
vn_submit_vkGetDeviceQueue(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue,struct vn_instance_submit_command * submit)12796 static inline void vn_submit_vkGetDeviceQueue(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue, struct vn_instance_submit_command *submit)
12797 {
12798 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12799 void *cmd_data = local_cmd_data;
12800 size_t cmd_size = vn_sizeof_vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
12801 if (cmd_size > sizeof(local_cmd_data)) {
12802 cmd_data = malloc(cmd_size);
12803 if (!cmd_data)
12804 cmd_size = 0;
12805 }
12806 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceQueue_reply(device, queueFamilyIndex, queueIndex, pQueue) : 0;
12807
12808 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12809 if (cmd_size) {
12810 vn_encode_vkGetDeviceQueue(enc, cmd_flags, device, queueFamilyIndex, queueIndex, pQueue);
12811 vn_instance_submit_command(vn_instance, submit);
12812 if (cmd_data != local_cmd_data)
12813 free(cmd_data);
12814 }
12815 }
12816
vn_submit_vkDeviceWaitIdle(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,struct vn_instance_submit_command * submit)12817 static inline void vn_submit_vkDeviceWaitIdle(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, struct vn_instance_submit_command *submit)
12818 {
12819 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12820 void *cmd_data = local_cmd_data;
12821 size_t cmd_size = vn_sizeof_vkDeviceWaitIdle(device);
12822 if (cmd_size > sizeof(local_cmd_data)) {
12823 cmd_data = malloc(cmd_size);
12824 if (!cmd_data)
12825 cmd_size = 0;
12826 }
12827 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDeviceWaitIdle_reply(device) : 0;
12828
12829 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12830 if (cmd_size) {
12831 vn_encode_vkDeviceWaitIdle(enc, cmd_flags, device);
12832 vn_instance_submit_command(vn_instance, submit);
12833 if (cmd_data != local_cmd_data)
12834 free(cmd_data);
12835 }
12836 }
12837
vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties,struct vn_instance_submit_command * submit)12838 static inline void vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties, struct vn_instance_submit_command *submit)
12839 {
12840 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12841 void *cmd_data = local_cmd_data;
12842 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
12843 if (cmd_size > sizeof(local_cmd_data)) {
12844 cmd_data = malloc(cmd_size);
12845 if (!cmd_data)
12846 cmd_size = 0;
12847 }
12848 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties_reply(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties) : 0;
12849
12850 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12851 if (cmd_size) {
12852 vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties(enc, cmd_flags, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
12853 vn_instance_submit_command(vn_instance, submit);
12854 if (cmd_data != local_cmd_data)
12855 free(cmd_data);
12856 }
12857 }
12858
vn_submit_vkGetPhysicalDeviceFeatures2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures,struct vn_instance_submit_command * submit)12859 static inline void vn_submit_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures, struct vn_instance_submit_command *submit)
12860 {
12861 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12862 void *cmd_data = local_cmd_data;
12863 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
12864 if (cmd_size > sizeof(local_cmd_data)) {
12865 cmd_data = malloc(cmd_size);
12866 if (!cmd_data)
12867 cmd_size = 0;
12868 }
12869 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(physicalDevice, pFeatures) : 0;
12870
12871 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12872 if (cmd_size) {
12873 vn_encode_vkGetPhysicalDeviceFeatures2(enc, cmd_flags, physicalDevice, pFeatures);
12874 vn_instance_submit_command(vn_instance, submit);
12875 if (cmd_data != local_cmd_data)
12876 free(cmd_data);
12877 }
12878 }
12879
vn_submit_vkGetPhysicalDeviceProperties2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties,struct vn_instance_submit_command * submit)12880 static inline void vn_submit_vkGetPhysicalDeviceProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties, struct vn_instance_submit_command *submit)
12881 {
12882 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12883 void *cmd_data = local_cmd_data;
12884 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceProperties2(physicalDevice, pProperties);
12885 if (cmd_size > sizeof(local_cmd_data)) {
12886 cmd_data = malloc(cmd_size);
12887 if (!cmd_data)
12888 cmd_size = 0;
12889 }
12890 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceProperties2_reply(physicalDevice, pProperties) : 0;
12891
12892 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12893 if (cmd_size) {
12894 vn_encode_vkGetPhysicalDeviceProperties2(enc, cmd_flags, physicalDevice, pProperties);
12895 vn_instance_submit_command(vn_instance, submit);
12896 if (cmd_data != local_cmd_data)
12897 free(cmd_data);
12898 }
12899 }
12900
vn_submit_vkGetPhysicalDeviceFormatProperties2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties,struct vn_instance_submit_command * submit)12901 static inline void vn_submit_vkGetPhysicalDeviceFormatProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties, struct vn_instance_submit_command *submit)
12902 {
12903 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12904 void *cmd_data = local_cmd_data;
12905 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
12906 if (cmd_size > sizeof(local_cmd_data)) {
12907 cmd_data = malloc(cmd_size);
12908 if (!cmd_data)
12909 cmd_size = 0;
12910 }
12911 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(physicalDevice, format, pFormatProperties) : 0;
12912
12913 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12914 if (cmd_size) {
12915 vn_encode_vkGetPhysicalDeviceFormatProperties2(enc, cmd_flags, physicalDevice, format, pFormatProperties);
12916 vn_instance_submit_command(vn_instance, submit);
12917 if (cmd_data != local_cmd_data)
12918 free(cmd_data);
12919 }
12920 }
12921
vn_submit_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties,struct vn_instance_submit_command * submit)12922 static inline void vn_submit_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties, struct vn_instance_submit_command *submit)
12923 {
12924 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12925 void *cmd_data = local_cmd_data;
12926 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties);
12927 if (cmd_size > sizeof(local_cmd_data)) {
12928 cmd_data = malloc(cmd_size);
12929 if (!cmd_data)
12930 cmd_size = 0;
12931 }
12932 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(physicalDevice, pImageFormatInfo, pImageFormatProperties) : 0;
12933
12934 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12935 if (cmd_size) {
12936 vn_encode_vkGetPhysicalDeviceImageFormatProperties2(enc, cmd_flags, physicalDevice, pImageFormatInfo, pImageFormatProperties);
12937 vn_instance_submit_command(vn_instance, submit);
12938 if (cmd_data != local_cmd_data)
12939 free(cmd_data);
12940 }
12941 }
12942
vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties,struct vn_instance_submit_command * submit)12943 static inline void vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties, struct vn_instance_submit_command *submit)
12944 {
12945 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12946 void *cmd_data = local_cmd_data;
12947 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
12948 if (cmd_size > sizeof(local_cmd_data)) {
12949 cmd_data = malloc(cmd_size);
12950 if (!cmd_data)
12951 cmd_size = 0;
12952 }
12953 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) : 0;
12954
12955 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12956 if (cmd_size) {
12957 vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(enc, cmd_flags, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
12958 vn_instance_submit_command(vn_instance, submit);
12959 if (cmd_data != local_cmd_data)
12960 free(cmd_data);
12961 }
12962 }
12963
vn_submit_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties,struct vn_instance_submit_command * submit)12964 static inline void vn_submit_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties, struct vn_instance_submit_command *submit)
12965 {
12966 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12967 void *cmd_data = local_cmd_data;
12968 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
12969 if (cmd_size > sizeof(local_cmd_data)) {
12970 cmd_data = malloc(cmd_size);
12971 if (!cmd_data)
12972 cmd_size = 0;
12973 }
12974 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(physicalDevice, pMemoryProperties) : 0;
12975
12976 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12977 if (cmd_size) {
12978 vn_encode_vkGetPhysicalDeviceMemoryProperties2(enc, cmd_flags, physicalDevice, pMemoryProperties);
12979 vn_instance_submit_command(vn_instance, submit);
12980 if (cmd_data != local_cmd_data)
12981 free(cmd_data);
12982 }
12983 }
12984
vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties,struct vn_instance_submit_command * submit)12985 static inline void vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties, struct vn_instance_submit_command *submit)
12986 {
12987 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12988 void *cmd_data = local_cmd_data;
12989 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
12990 if (cmd_size > sizeof(local_cmd_data)) {
12991 cmd_data = malloc(cmd_size);
12992 if (!cmd_data)
12993 cmd_size = 0;
12994 }
12995 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(physicalDevice, pFormatInfo, pPropertyCount, pProperties) : 0;
12996
12997 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12998 if (cmd_size) {
12999 vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(enc, cmd_flags, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
13000 vn_instance_submit_command(vn_instance, submit);
13001 if (cmd_data != local_cmd_data)
13002 free(cmd_data);
13003 }
13004 }
13005
vn_submit_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties,struct vn_instance_submit_command * submit)13006 static inline void vn_submit_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties, struct vn_instance_submit_command *submit)
13007 {
13008 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
13009 void *cmd_data = local_cmd_data;
13010 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
13011 if (cmd_size > sizeof(local_cmd_data)) {
13012 cmd_data = malloc(cmd_size);
13013 if (!cmd_data)
13014 cmd_size = 0;
13015 }
13016 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(physicalDevice, pExternalBufferInfo, pExternalBufferProperties) : 0;
13017
13018 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
13019 if (cmd_size) {
13020 vn_encode_vkGetPhysicalDeviceExternalBufferProperties(enc, cmd_flags, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
13021 vn_instance_submit_command(vn_instance, submit);
13022 if (cmd_data != local_cmd_data)
13023 free(cmd_data);
13024 }
13025 }
13026
vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties,struct vn_instance_submit_command * submit)13027 static inline void vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties, struct vn_instance_submit_command *submit)
13028 {
13029 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
13030 void *cmd_data = local_cmd_data;
13031 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
13032 if (cmd_size > sizeof(local_cmd_data)) {
13033 cmd_data = malloc(cmd_size);
13034 if (!cmd_data)
13035 cmd_size = 0;
13036 }
13037 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties) : 0;
13038
13039 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
13040 if (cmd_size) {
13041 vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(enc, cmd_flags, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
13042 vn_instance_submit_command(vn_instance, submit);
13043 if (cmd_data != local_cmd_data)
13044 free(cmd_data);
13045 }
13046 }
13047
vn_submit_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties,struct vn_instance_submit_command * submit)13048 static inline void vn_submit_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties, struct vn_instance_submit_command *submit)
13049 {
13050 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
13051 void *cmd_data = local_cmd_data;
13052 size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
13053 if (cmd_size > sizeof(local_cmd_data)) {
13054 cmd_data = malloc(cmd_size);
13055 if (!cmd_data)
13056 cmd_size = 0;
13057 }
13058 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(physicalDevice, pExternalFenceInfo, pExternalFenceProperties) : 0;
13059
13060 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
13061 if (cmd_size) {
13062 vn_encode_vkGetPhysicalDeviceExternalFenceProperties(enc, cmd_flags, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
13063 vn_instance_submit_command(vn_instance, submit);
13064 if (cmd_data != local_cmd_data)
13065 free(cmd_data);
13066 }
13067 }
13068
vn_submit_vkEnumeratePhysicalDeviceGroups(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,struct vn_instance_submit_command * submit)13069 static inline void vn_submit_vkEnumeratePhysicalDeviceGroups(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, struct vn_instance_submit_command *submit)
13070 {
13071 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
13072 void *cmd_data = local_cmd_data;
13073 size_t cmd_size = vn_sizeof_vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
13074 if (cmd_size > sizeof(local_cmd_data)) {
13075 cmd_data = malloc(cmd_size);
13076 if (!cmd_data)
13077 cmd_size = 0;
13078 }
13079 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties) : 0;
13080
13081 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
13082 if (cmd_size) {
13083 vn_encode_vkEnumeratePhysicalDeviceGroups(enc, cmd_flags, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
13084 vn_instance_submit_command(vn_instance, submit);
13085 if (cmd_data != local_cmd_data)
13086 free(cmd_data);
13087 }
13088 }
13089
vn_submit_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures,struct vn_instance_submit_command * submit)13090 static inline void vn_submit_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures, struct vn_instance_submit_command *submit)
13091 {
13092 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
13093 void *cmd_data = local_cmd_data;
13094 size_t cmd_size = vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
13095 if (cmd_size > sizeof(local_cmd_data)) {
13096 cmd_data = malloc(cmd_size);
13097 if (!cmd_data)
13098 cmd_size = 0;
13099 }
13100 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures) : 0;
13101
13102 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
13103 if (cmd_size) {
13104 vn_encode_vkGetDeviceGroupPeerMemoryFeatures(enc, cmd_flags, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
13105 vn_instance_submit_command(vn_instance, submit);
13106 if (cmd_data != local_cmd_data)
13107 free(cmd_data);
13108 }
13109 }
13110
vn_submit_vkGetDeviceQueue2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue,struct vn_instance_submit_command * submit)13111 static inline void vn_submit_vkGetDeviceQueue2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue, struct vn_instance_submit_command *submit)
13112 {
13113 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
13114 void *cmd_data = local_cmd_data;
13115 size_t cmd_size = vn_sizeof_vkGetDeviceQueue2(device, pQueueInfo, pQueue);
13116 if (cmd_size > sizeof(local_cmd_data)) {
13117 cmd_data = malloc(cmd_size);
13118 if (!cmd_data)
13119 cmd_size = 0;
13120 }
13121 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceQueue2_reply(device, pQueueInfo, pQueue) : 0;
13122
13123 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
13124 if (cmd_size) {
13125 vn_encode_vkGetDeviceQueue2(enc, cmd_flags, device, pQueueInfo, pQueue);
13126 vn_instance_submit_command(vn_instance, submit);
13127 if (cmd_data != local_cmd_data)
13128 free(cmd_data);
13129 }
13130 }
13131
vn_call_vkEnumeratePhysicalDevices(struct vn_instance * vn_instance,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)13132 static inline VkResult vn_call_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
13133 {
13134 VN_TRACE_FUNC();
13135
13136 struct vn_instance_submit_command submit;
13137 vn_submit_vkEnumeratePhysicalDevices(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pPhysicalDeviceCount, pPhysicalDevices, &submit);
13138 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13139 if (dec) {
13140 const VkResult ret = vn_decode_vkEnumeratePhysicalDevices_reply(dec, instance, pPhysicalDeviceCount, pPhysicalDevices);
13141 vn_instance_free_command_reply(vn_instance, &submit);
13142 return ret;
13143 } else {
13144 return VK_ERROR_OUT_OF_HOST_MEMORY;
13145 }
13146 }
13147
vn_async_vkEnumeratePhysicalDevices(struct vn_instance * vn_instance,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)13148 static inline void vn_async_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
13149 {
13150 struct vn_instance_submit_command submit;
13151 vn_submit_vkEnumeratePhysicalDevices(vn_instance, 0, instance, pPhysicalDeviceCount, pPhysicalDevices, &submit);
13152 }
13153
vn_call_vkGetPhysicalDeviceProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)13154 static inline void vn_call_vkGetPhysicalDeviceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
13155 {
13156 VN_TRACE_FUNC();
13157
13158 struct vn_instance_submit_command submit;
13159 vn_submit_vkGetPhysicalDeviceProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pProperties, &submit);
13160 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13161 if (dec) {
13162 vn_decode_vkGetPhysicalDeviceProperties_reply(dec, physicalDevice, pProperties);
13163 vn_instance_free_command_reply(vn_instance, &submit);
13164 }
13165 }
13166
vn_async_vkGetPhysicalDeviceProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)13167 static inline void vn_async_vkGetPhysicalDeviceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
13168 {
13169 struct vn_instance_submit_command submit;
13170 vn_submit_vkGetPhysicalDeviceProperties(vn_instance, 0, physicalDevice, pProperties, &submit);
13171 }
13172
vn_call_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)13173 static inline void vn_call_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
13174 {
13175 VN_TRACE_FUNC();
13176
13177 struct vn_instance_submit_command submit;
13178 vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
13179 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13180 if (dec) {
13181 vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(dec, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
13182 vn_instance_free_command_reply(vn_instance, &submit);
13183 }
13184 }
13185
vn_async_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)13186 static inline void vn_async_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
13187 {
13188 struct vn_instance_submit_command submit;
13189 vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(vn_instance, 0, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
13190 }
13191
vn_call_vkGetPhysicalDeviceMemoryProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)13192 static inline void vn_call_vkGetPhysicalDeviceMemoryProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
13193 {
13194 VN_TRACE_FUNC();
13195
13196 struct vn_instance_submit_command submit;
13197 vn_submit_vkGetPhysicalDeviceMemoryProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pMemoryProperties, &submit);
13198 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13199 if (dec) {
13200 vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(dec, physicalDevice, pMemoryProperties);
13201 vn_instance_free_command_reply(vn_instance, &submit);
13202 }
13203 }
13204
vn_async_vkGetPhysicalDeviceMemoryProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)13205 static inline void vn_async_vkGetPhysicalDeviceMemoryProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
13206 {
13207 struct vn_instance_submit_command submit;
13208 vn_submit_vkGetPhysicalDeviceMemoryProperties(vn_instance, 0, physicalDevice, pMemoryProperties, &submit);
13209 }
13210
vn_call_vkGetPhysicalDeviceFeatures(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)13211 static inline void vn_call_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
13212 {
13213 VN_TRACE_FUNC();
13214
13215 struct vn_instance_submit_command submit;
13216 vn_submit_vkGetPhysicalDeviceFeatures(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFeatures, &submit);
13217 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13218 if (dec) {
13219 vn_decode_vkGetPhysicalDeviceFeatures_reply(dec, physicalDevice, pFeatures);
13220 vn_instance_free_command_reply(vn_instance, &submit);
13221 }
13222 }
13223
vn_async_vkGetPhysicalDeviceFeatures(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)13224 static inline void vn_async_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
13225 {
13226 struct vn_instance_submit_command submit;
13227 vn_submit_vkGetPhysicalDeviceFeatures(vn_instance, 0, physicalDevice, pFeatures, &submit);
13228 }
13229
vn_call_vkGetPhysicalDeviceFormatProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)13230 static inline void vn_call_vkGetPhysicalDeviceFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
13231 {
13232 VN_TRACE_FUNC();
13233
13234 struct vn_instance_submit_command submit;
13235 vn_submit_vkGetPhysicalDeviceFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, pFormatProperties, &submit);
13236 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13237 if (dec) {
13238 vn_decode_vkGetPhysicalDeviceFormatProperties_reply(dec, physicalDevice, format, pFormatProperties);
13239 vn_instance_free_command_reply(vn_instance, &submit);
13240 }
13241 }
13242
vn_async_vkGetPhysicalDeviceFormatProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)13243 static inline void vn_async_vkGetPhysicalDeviceFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
13244 {
13245 struct vn_instance_submit_command submit;
13246 vn_submit_vkGetPhysicalDeviceFormatProperties(vn_instance, 0, physicalDevice, format, pFormatProperties, &submit);
13247 }
13248
vn_call_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)13249 static inline VkResult vn_call_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
13250 {
13251 VN_TRACE_FUNC();
13252
13253 struct vn_instance_submit_command submit;
13254 vn_submit_vkGetPhysicalDeviceImageFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, &submit);
13255 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13256 if (dec) {
13257 const VkResult ret = vn_decode_vkGetPhysicalDeviceImageFormatProperties_reply(dec, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
13258 vn_instance_free_command_reply(vn_instance, &submit);
13259 return ret;
13260 } else {
13261 return VK_ERROR_OUT_OF_HOST_MEMORY;
13262 }
13263 }
13264
vn_async_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)13265 static inline void vn_async_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
13266 {
13267 struct vn_instance_submit_command submit;
13268 vn_submit_vkGetPhysicalDeviceImageFormatProperties(vn_instance, 0, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, &submit);
13269 }
13270
vn_call_vkCreateDevice(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)13271 static inline VkResult vn_call_vkCreateDevice(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
13272 {
13273 VN_TRACE_FUNC();
13274
13275 struct vn_instance_submit_command submit;
13276 vn_submit_vkCreateDevice(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pCreateInfo, pAllocator, pDevice, &submit);
13277 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13278 if (dec) {
13279 const VkResult ret = vn_decode_vkCreateDevice_reply(dec, physicalDevice, pCreateInfo, pAllocator, pDevice);
13280 vn_instance_free_command_reply(vn_instance, &submit);
13281 return ret;
13282 } else {
13283 return VK_ERROR_OUT_OF_HOST_MEMORY;
13284 }
13285 }
13286
vn_async_vkCreateDevice(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)13287 static inline void vn_async_vkCreateDevice(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
13288 {
13289 struct vn_instance_submit_command submit;
13290 vn_submit_vkCreateDevice(vn_instance, 0, physicalDevice, pCreateInfo, pAllocator, pDevice, &submit);
13291 }
13292
vn_call_vkDestroyDevice(struct vn_instance * vn_instance,VkDevice device,const VkAllocationCallbacks * pAllocator)13293 static inline void vn_call_vkDestroyDevice(struct vn_instance *vn_instance, VkDevice device, const VkAllocationCallbacks* pAllocator)
13294 {
13295 VN_TRACE_FUNC();
13296
13297 struct vn_instance_submit_command submit;
13298 vn_submit_vkDestroyDevice(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocator, &submit);
13299 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13300 if (dec) {
13301 vn_decode_vkDestroyDevice_reply(dec, device, pAllocator);
13302 vn_instance_free_command_reply(vn_instance, &submit);
13303 }
13304 }
13305
vn_async_vkDestroyDevice(struct vn_instance * vn_instance,VkDevice device,const VkAllocationCallbacks * pAllocator)13306 static inline void vn_async_vkDestroyDevice(struct vn_instance *vn_instance, VkDevice device, const VkAllocationCallbacks* pAllocator)
13307 {
13308 struct vn_instance_submit_command submit;
13309 vn_submit_vkDestroyDevice(vn_instance, 0, device, pAllocator, &submit);
13310 }
13311
vn_call_vkEnumerateDeviceLayerProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)13312 static inline VkResult vn_call_vkEnumerateDeviceLayerProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
13313 {
13314 VN_TRACE_FUNC();
13315
13316 struct vn_instance_submit_command submit;
13317 vn_submit_vkEnumerateDeviceLayerProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pPropertyCount, pProperties, &submit);
13318 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13319 if (dec) {
13320 const VkResult ret = vn_decode_vkEnumerateDeviceLayerProperties_reply(dec, physicalDevice, pPropertyCount, pProperties);
13321 vn_instance_free_command_reply(vn_instance, &submit);
13322 return ret;
13323 } else {
13324 return VK_ERROR_OUT_OF_HOST_MEMORY;
13325 }
13326 }
13327
vn_async_vkEnumerateDeviceLayerProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)13328 static inline void vn_async_vkEnumerateDeviceLayerProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
13329 {
13330 struct vn_instance_submit_command submit;
13331 vn_submit_vkEnumerateDeviceLayerProperties(vn_instance, 0, physicalDevice, pPropertyCount, pProperties, &submit);
13332 }
13333
vn_call_vkEnumerateDeviceExtensionProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)13334 static inline VkResult vn_call_vkEnumerateDeviceExtensionProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
13335 {
13336 VN_TRACE_FUNC();
13337
13338 struct vn_instance_submit_command submit;
13339 vn_submit_vkEnumerateDeviceExtensionProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pLayerName, pPropertyCount, pProperties, &submit);
13340 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13341 if (dec) {
13342 const VkResult ret = vn_decode_vkEnumerateDeviceExtensionProperties_reply(dec, physicalDevice, pLayerName, pPropertyCount, pProperties);
13343 vn_instance_free_command_reply(vn_instance, &submit);
13344 return ret;
13345 } else {
13346 return VK_ERROR_OUT_OF_HOST_MEMORY;
13347 }
13348 }
13349
vn_async_vkEnumerateDeviceExtensionProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)13350 static inline void vn_async_vkEnumerateDeviceExtensionProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
13351 {
13352 struct vn_instance_submit_command submit;
13353 vn_submit_vkEnumerateDeviceExtensionProperties(vn_instance, 0, physicalDevice, pLayerName, pPropertyCount, pProperties, &submit);
13354 }
13355
vn_call_vkGetDeviceQueue(struct vn_instance * vn_instance,VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)13356 static inline void vn_call_vkGetDeviceQueue(struct vn_instance *vn_instance, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
13357 {
13358 VN_TRACE_FUNC();
13359
13360 struct vn_instance_submit_command submit;
13361 vn_submit_vkGetDeviceQueue(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queueFamilyIndex, queueIndex, pQueue, &submit);
13362 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13363 if (dec) {
13364 vn_decode_vkGetDeviceQueue_reply(dec, device, queueFamilyIndex, queueIndex, pQueue);
13365 vn_instance_free_command_reply(vn_instance, &submit);
13366 }
13367 }
13368
vn_async_vkGetDeviceQueue(struct vn_instance * vn_instance,VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)13369 static inline void vn_async_vkGetDeviceQueue(struct vn_instance *vn_instance, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
13370 {
13371 struct vn_instance_submit_command submit;
13372 vn_submit_vkGetDeviceQueue(vn_instance, 0, device, queueFamilyIndex, queueIndex, pQueue, &submit);
13373 }
13374
vn_call_vkDeviceWaitIdle(struct vn_instance * vn_instance,VkDevice device)13375 static inline VkResult vn_call_vkDeviceWaitIdle(struct vn_instance *vn_instance, VkDevice device)
13376 {
13377 VN_TRACE_FUNC();
13378
13379 struct vn_instance_submit_command submit;
13380 vn_submit_vkDeviceWaitIdle(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, &submit);
13381 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13382 if (dec) {
13383 const VkResult ret = vn_decode_vkDeviceWaitIdle_reply(dec, device);
13384 vn_instance_free_command_reply(vn_instance, &submit);
13385 return ret;
13386 } else {
13387 return VK_ERROR_OUT_OF_HOST_MEMORY;
13388 }
13389 }
13390
vn_async_vkDeviceWaitIdle(struct vn_instance * vn_instance,VkDevice device)13391 static inline void vn_async_vkDeviceWaitIdle(struct vn_instance *vn_instance, VkDevice device)
13392 {
13393 struct vn_instance_submit_command submit;
13394 vn_submit_vkDeviceWaitIdle(vn_instance, 0, device, &submit);
13395 }
13396
vn_call_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)13397 static inline void vn_call_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
13398 {
13399 VN_TRACE_FUNC();
13400
13401 struct vn_instance_submit_command submit;
13402 vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties, &submit);
13403 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13404 if (dec) {
13405 vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties_reply(dec, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
13406 vn_instance_free_command_reply(vn_instance, &submit);
13407 }
13408 }
13409
vn_async_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)13410 static inline void vn_async_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
13411 {
13412 struct vn_instance_submit_command submit;
13413 vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(vn_instance, 0, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties, &submit);
13414 }
13415
vn_call_vkGetPhysicalDeviceFeatures2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)13416 static inline void vn_call_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
13417 {
13418 VN_TRACE_FUNC();
13419
13420 struct vn_instance_submit_command submit;
13421 vn_submit_vkGetPhysicalDeviceFeatures2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFeatures, &submit);
13422 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13423 if (dec) {
13424 vn_decode_vkGetPhysicalDeviceFeatures2_reply(dec, physicalDevice, pFeatures);
13425 vn_instance_free_command_reply(vn_instance, &submit);
13426 }
13427 }
13428
vn_async_vkGetPhysicalDeviceFeatures2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)13429 static inline void vn_async_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
13430 {
13431 struct vn_instance_submit_command submit;
13432 vn_submit_vkGetPhysicalDeviceFeatures2(vn_instance, 0, physicalDevice, pFeatures, &submit);
13433 }
13434
vn_call_vkGetPhysicalDeviceProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)13435 static inline void vn_call_vkGetPhysicalDeviceProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
13436 {
13437 VN_TRACE_FUNC();
13438
13439 struct vn_instance_submit_command submit;
13440 vn_submit_vkGetPhysicalDeviceProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pProperties, &submit);
13441 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13442 if (dec) {
13443 vn_decode_vkGetPhysicalDeviceProperties2_reply(dec, physicalDevice, pProperties);
13444 vn_instance_free_command_reply(vn_instance, &submit);
13445 }
13446 }
13447
vn_async_vkGetPhysicalDeviceProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)13448 static inline void vn_async_vkGetPhysicalDeviceProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
13449 {
13450 struct vn_instance_submit_command submit;
13451 vn_submit_vkGetPhysicalDeviceProperties2(vn_instance, 0, physicalDevice, pProperties, &submit);
13452 }
13453
vn_call_vkGetPhysicalDeviceFormatProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)13454 static inline void vn_call_vkGetPhysicalDeviceFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
13455 {
13456 VN_TRACE_FUNC();
13457
13458 struct vn_instance_submit_command submit;
13459 vn_submit_vkGetPhysicalDeviceFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, pFormatProperties, &submit);
13460 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13461 if (dec) {
13462 vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(dec, physicalDevice, format, pFormatProperties);
13463 vn_instance_free_command_reply(vn_instance, &submit);
13464 }
13465 }
13466
vn_async_vkGetPhysicalDeviceFormatProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)13467 static inline void vn_async_vkGetPhysicalDeviceFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
13468 {
13469 struct vn_instance_submit_command submit;
13470 vn_submit_vkGetPhysicalDeviceFormatProperties2(vn_instance, 0, physicalDevice, format, pFormatProperties, &submit);
13471 }
13472
vn_call_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)13473 static inline VkResult vn_call_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
13474 {
13475 VN_TRACE_FUNC();
13476
13477 struct vn_instance_submit_command submit;
13478 vn_submit_vkGetPhysicalDeviceImageFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pImageFormatInfo, pImageFormatProperties, &submit);
13479 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13480 if (dec) {
13481 const VkResult ret = vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(dec, physicalDevice, pImageFormatInfo, pImageFormatProperties);
13482 vn_instance_free_command_reply(vn_instance, &submit);
13483 return ret;
13484 } else {
13485 return VK_ERROR_OUT_OF_HOST_MEMORY;
13486 }
13487 }
13488
vn_async_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)13489 static inline void vn_async_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
13490 {
13491 struct vn_instance_submit_command submit;
13492 vn_submit_vkGetPhysicalDeviceImageFormatProperties2(vn_instance, 0, physicalDevice, pImageFormatInfo, pImageFormatProperties, &submit);
13493 }
13494
vn_call_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)13495 static inline void vn_call_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
13496 {
13497 VN_TRACE_FUNC();
13498
13499 struct vn_instance_submit_command submit;
13500 vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
13501 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13502 if (dec) {
13503 vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(dec, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
13504 vn_instance_free_command_reply(vn_instance, &submit);
13505 }
13506 }
13507
vn_async_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)13508 static inline void vn_async_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
13509 {
13510 struct vn_instance_submit_command submit;
13511 vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(vn_instance, 0, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
13512 }
13513
vn_call_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)13514 static inline void vn_call_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
13515 {
13516 VN_TRACE_FUNC();
13517
13518 struct vn_instance_submit_command submit;
13519 vn_submit_vkGetPhysicalDeviceMemoryProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pMemoryProperties, &submit);
13520 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13521 if (dec) {
13522 vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(dec, physicalDevice, pMemoryProperties);
13523 vn_instance_free_command_reply(vn_instance, &submit);
13524 }
13525 }
13526
vn_async_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)13527 static inline void vn_async_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
13528 {
13529 struct vn_instance_submit_command submit;
13530 vn_submit_vkGetPhysicalDeviceMemoryProperties2(vn_instance, 0, physicalDevice, pMemoryProperties, &submit);
13531 }
13532
vn_call_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)13533 static inline void vn_call_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
13534 {
13535 VN_TRACE_FUNC();
13536
13537 struct vn_instance_submit_command submit;
13538 vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFormatInfo, pPropertyCount, pProperties, &submit);
13539 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13540 if (dec) {
13541 vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(dec, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
13542 vn_instance_free_command_reply(vn_instance, &submit);
13543 }
13544 }
13545
vn_async_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)13546 static inline void vn_async_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
13547 {
13548 struct vn_instance_submit_command submit;
13549 vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(vn_instance, 0, physicalDevice, pFormatInfo, pPropertyCount, pProperties, &submit);
13550 }
13551
vn_call_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)13552 static inline void vn_call_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
13553 {
13554 VN_TRACE_FUNC();
13555
13556 struct vn_instance_submit_command submit;
13557 vn_submit_vkGetPhysicalDeviceExternalBufferProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalBufferInfo, pExternalBufferProperties, &submit);
13558 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13559 if (dec) {
13560 vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(dec, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
13561 vn_instance_free_command_reply(vn_instance, &submit);
13562 }
13563 }
13564
vn_async_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)13565 static inline void vn_async_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
13566 {
13567 struct vn_instance_submit_command submit;
13568 vn_submit_vkGetPhysicalDeviceExternalBufferProperties(vn_instance, 0, physicalDevice, pExternalBufferInfo, pExternalBufferProperties, &submit);
13569 }
13570
vn_call_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)13571 static inline void vn_call_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
13572 {
13573 VN_TRACE_FUNC();
13574
13575 struct vn_instance_submit_command submit;
13576 vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, &submit);
13577 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13578 if (dec) {
13579 vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(dec, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
13580 vn_instance_free_command_reply(vn_instance, &submit);
13581 }
13582 }
13583
vn_async_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)13584 static inline void vn_async_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
13585 {
13586 struct vn_instance_submit_command submit;
13587 vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(vn_instance, 0, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, &submit);
13588 }
13589
vn_call_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)13590 static inline void vn_call_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
13591 {
13592 VN_TRACE_FUNC();
13593
13594 struct vn_instance_submit_command submit;
13595 vn_submit_vkGetPhysicalDeviceExternalFenceProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalFenceInfo, pExternalFenceProperties, &submit);
13596 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13597 if (dec) {
13598 vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(dec, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
13599 vn_instance_free_command_reply(vn_instance, &submit);
13600 }
13601 }
13602
vn_async_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)13603 static inline void vn_async_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
13604 {
13605 struct vn_instance_submit_command submit;
13606 vn_submit_vkGetPhysicalDeviceExternalFenceProperties(vn_instance, 0, physicalDevice, pExternalFenceInfo, pExternalFenceProperties, &submit);
13607 }
13608
vn_call_vkEnumeratePhysicalDeviceGroups(struct vn_instance * vn_instance,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)13609 static inline VkResult vn_call_vkEnumeratePhysicalDeviceGroups(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
13610 {
13611 VN_TRACE_FUNC();
13612
13613 struct vn_instance_submit_command submit;
13614 vn_submit_vkEnumeratePhysicalDeviceGroups(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, &submit);
13615 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13616 if (dec) {
13617 const VkResult ret = vn_decode_vkEnumeratePhysicalDeviceGroups_reply(dec, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
13618 vn_instance_free_command_reply(vn_instance, &submit);
13619 return ret;
13620 } else {
13621 return VK_ERROR_OUT_OF_HOST_MEMORY;
13622 }
13623 }
13624
vn_async_vkEnumeratePhysicalDeviceGroups(struct vn_instance * vn_instance,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)13625 static inline void vn_async_vkEnumeratePhysicalDeviceGroups(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
13626 {
13627 struct vn_instance_submit_command submit;
13628 vn_submit_vkEnumeratePhysicalDeviceGroups(vn_instance, 0, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, &submit);
13629 }
13630
vn_call_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance * vn_instance,VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)13631 static inline void vn_call_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance *vn_instance, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
13632 {
13633 VN_TRACE_FUNC();
13634
13635 struct vn_instance_submit_command submit;
13636 vn_submit_vkGetDeviceGroupPeerMemoryFeatures(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, &submit);
13637 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13638 if (dec) {
13639 vn_decode_vkGetDeviceGroupPeerMemoryFeatures_reply(dec, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
13640 vn_instance_free_command_reply(vn_instance, &submit);
13641 }
13642 }
13643
vn_async_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance * vn_instance,VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)13644 static inline void vn_async_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance *vn_instance, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
13645 {
13646 struct vn_instance_submit_command submit;
13647 vn_submit_vkGetDeviceGroupPeerMemoryFeatures(vn_instance, 0, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, &submit);
13648 }
13649
vn_call_vkGetDeviceQueue2(struct vn_instance * vn_instance,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)13650 static inline void vn_call_vkGetDeviceQueue2(struct vn_instance *vn_instance, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
13651 {
13652 VN_TRACE_FUNC();
13653
13654 struct vn_instance_submit_command submit;
13655 vn_submit_vkGetDeviceQueue2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pQueueInfo, pQueue, &submit);
13656 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13657 if (dec) {
13658 vn_decode_vkGetDeviceQueue2_reply(dec, device, pQueueInfo, pQueue);
13659 vn_instance_free_command_reply(vn_instance, &submit);
13660 }
13661 }
13662
vn_async_vkGetDeviceQueue2(struct vn_instance * vn_instance,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)13663 static inline void vn_async_vkGetDeviceQueue2(struct vn_instance *vn_instance, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
13664 {
13665 struct vn_instance_submit_command submit;
13666 vn_submit_vkGetDeviceQueue2(vn_instance, 0, device, pQueueInfo, pQueue, &submit);
13667 }
13668
13669 #endif /* VN_PROTOCOL_DRIVER_DEVICE_H */
13670