1 /* This file is generated by venus-protocol. See vn_protocol_renderer.h. */
2
3 /*
4 * Copyright 2020 Google LLC
5 * SPDX-License-Identifier: MIT
6 */
7
8 #ifndef VN_PROTOCOL_RENDERER_DEVICE_H
9 #define VN_PROTOCOL_RENDERER_DEVICE_H
10
11 #include "vn_protocol_renderer_structs.h"
12
13 #pragma GCC diagnostic push
14 #pragma GCC diagnostic ignored "-Wpointer-arith"
15 #pragma GCC diagnostic ignored "-Wunused-parameter"
16
17 /*
18 * These structs/unions/commands are not included
19 *
20 * vkGetDeviceProcAddr
21 */
22
23 /* struct VkPhysicalDeviceLimits */
24
25 static inline void
vn_encode_VkPhysicalDeviceLimits(struct vn_cs_encoder * enc,const VkPhysicalDeviceLimits * val)26 vn_encode_VkPhysicalDeviceLimits(struct vn_cs_encoder *enc, const VkPhysicalDeviceLimits *val)
27 {
28 vn_encode_uint32_t(enc, &val->maxImageDimension1D);
29 vn_encode_uint32_t(enc, &val->maxImageDimension2D);
30 vn_encode_uint32_t(enc, &val->maxImageDimension3D);
31 vn_encode_uint32_t(enc, &val->maxImageDimensionCube);
32 vn_encode_uint32_t(enc, &val->maxImageArrayLayers);
33 vn_encode_uint32_t(enc, &val->maxTexelBufferElements);
34 vn_encode_uint32_t(enc, &val->maxUniformBufferRange);
35 vn_encode_uint32_t(enc, &val->maxStorageBufferRange);
36 vn_encode_uint32_t(enc, &val->maxPushConstantsSize);
37 vn_encode_uint32_t(enc, &val->maxMemoryAllocationCount);
38 vn_encode_uint32_t(enc, &val->maxSamplerAllocationCount);
39 vn_encode_VkDeviceSize(enc, &val->bufferImageGranularity);
40 vn_encode_VkDeviceSize(enc, &val->sparseAddressSpaceSize);
41 vn_encode_uint32_t(enc, &val->maxBoundDescriptorSets);
42 vn_encode_uint32_t(enc, &val->maxPerStageDescriptorSamplers);
43 vn_encode_uint32_t(enc, &val->maxPerStageDescriptorUniformBuffers);
44 vn_encode_uint32_t(enc, &val->maxPerStageDescriptorStorageBuffers);
45 vn_encode_uint32_t(enc, &val->maxPerStageDescriptorSampledImages);
46 vn_encode_uint32_t(enc, &val->maxPerStageDescriptorStorageImages);
47 vn_encode_uint32_t(enc, &val->maxPerStageDescriptorInputAttachments);
48 vn_encode_uint32_t(enc, &val->maxPerStageResources);
49 vn_encode_uint32_t(enc, &val->maxDescriptorSetSamplers);
50 vn_encode_uint32_t(enc, &val->maxDescriptorSetUniformBuffers);
51 vn_encode_uint32_t(enc, &val->maxDescriptorSetUniformBuffersDynamic);
52 vn_encode_uint32_t(enc, &val->maxDescriptorSetStorageBuffers);
53 vn_encode_uint32_t(enc, &val->maxDescriptorSetStorageBuffersDynamic);
54 vn_encode_uint32_t(enc, &val->maxDescriptorSetSampledImages);
55 vn_encode_uint32_t(enc, &val->maxDescriptorSetStorageImages);
56 vn_encode_uint32_t(enc, &val->maxDescriptorSetInputAttachments);
57 vn_encode_uint32_t(enc, &val->maxVertexInputAttributes);
58 vn_encode_uint32_t(enc, &val->maxVertexInputBindings);
59 vn_encode_uint32_t(enc, &val->maxVertexInputAttributeOffset);
60 vn_encode_uint32_t(enc, &val->maxVertexInputBindingStride);
61 vn_encode_uint32_t(enc, &val->maxVertexOutputComponents);
62 vn_encode_uint32_t(enc, &val->maxTessellationGenerationLevel);
63 vn_encode_uint32_t(enc, &val->maxTessellationPatchSize);
64 vn_encode_uint32_t(enc, &val->maxTessellationControlPerVertexInputComponents);
65 vn_encode_uint32_t(enc, &val->maxTessellationControlPerVertexOutputComponents);
66 vn_encode_uint32_t(enc, &val->maxTessellationControlPerPatchOutputComponents);
67 vn_encode_uint32_t(enc, &val->maxTessellationControlTotalOutputComponents);
68 vn_encode_uint32_t(enc, &val->maxTessellationEvaluationInputComponents);
69 vn_encode_uint32_t(enc, &val->maxTessellationEvaluationOutputComponents);
70 vn_encode_uint32_t(enc, &val->maxGeometryShaderInvocations);
71 vn_encode_uint32_t(enc, &val->maxGeometryInputComponents);
72 vn_encode_uint32_t(enc, &val->maxGeometryOutputComponents);
73 vn_encode_uint32_t(enc, &val->maxGeometryOutputVertices);
74 vn_encode_uint32_t(enc, &val->maxGeometryTotalOutputComponents);
75 vn_encode_uint32_t(enc, &val->maxFragmentInputComponents);
76 vn_encode_uint32_t(enc, &val->maxFragmentOutputAttachments);
77 vn_encode_uint32_t(enc, &val->maxFragmentDualSrcAttachments);
78 vn_encode_uint32_t(enc, &val->maxFragmentCombinedOutputResources);
79 vn_encode_uint32_t(enc, &val->maxComputeSharedMemorySize);
80 vn_encode_array_size(enc, 3);
81 vn_encode_uint32_t_array(enc, val->maxComputeWorkGroupCount, 3);
82 vn_encode_uint32_t(enc, &val->maxComputeWorkGroupInvocations);
83 vn_encode_array_size(enc, 3);
84 vn_encode_uint32_t_array(enc, val->maxComputeWorkGroupSize, 3);
85 vn_encode_uint32_t(enc, &val->subPixelPrecisionBits);
86 vn_encode_uint32_t(enc, &val->subTexelPrecisionBits);
87 vn_encode_uint32_t(enc, &val->mipmapPrecisionBits);
88 vn_encode_uint32_t(enc, &val->maxDrawIndexedIndexValue);
89 vn_encode_uint32_t(enc, &val->maxDrawIndirectCount);
90 vn_encode_float(enc, &val->maxSamplerLodBias);
91 vn_encode_float(enc, &val->maxSamplerAnisotropy);
92 vn_encode_uint32_t(enc, &val->maxViewports);
93 vn_encode_array_size(enc, 2);
94 vn_encode_uint32_t_array(enc, val->maxViewportDimensions, 2);
95 vn_encode_array_size(enc, 2);
96 vn_encode_float_array(enc, val->viewportBoundsRange, 2);
97 vn_encode_uint32_t(enc, &val->viewportSubPixelBits);
98 vn_encode_size_t(enc, &val->minMemoryMapAlignment);
99 vn_encode_VkDeviceSize(enc, &val->minTexelBufferOffsetAlignment);
100 vn_encode_VkDeviceSize(enc, &val->minUniformBufferOffsetAlignment);
101 vn_encode_VkDeviceSize(enc, &val->minStorageBufferOffsetAlignment);
102 vn_encode_int32_t(enc, &val->minTexelOffset);
103 vn_encode_uint32_t(enc, &val->maxTexelOffset);
104 vn_encode_int32_t(enc, &val->minTexelGatherOffset);
105 vn_encode_uint32_t(enc, &val->maxTexelGatherOffset);
106 vn_encode_float(enc, &val->minInterpolationOffset);
107 vn_encode_float(enc, &val->maxInterpolationOffset);
108 vn_encode_uint32_t(enc, &val->subPixelInterpolationOffsetBits);
109 vn_encode_uint32_t(enc, &val->maxFramebufferWidth);
110 vn_encode_uint32_t(enc, &val->maxFramebufferHeight);
111 vn_encode_uint32_t(enc, &val->maxFramebufferLayers);
112 vn_encode_VkFlags(enc, &val->framebufferColorSampleCounts);
113 vn_encode_VkFlags(enc, &val->framebufferDepthSampleCounts);
114 vn_encode_VkFlags(enc, &val->framebufferStencilSampleCounts);
115 vn_encode_VkFlags(enc, &val->framebufferNoAttachmentsSampleCounts);
116 vn_encode_uint32_t(enc, &val->maxColorAttachments);
117 vn_encode_VkFlags(enc, &val->sampledImageColorSampleCounts);
118 vn_encode_VkFlags(enc, &val->sampledImageIntegerSampleCounts);
119 vn_encode_VkFlags(enc, &val->sampledImageDepthSampleCounts);
120 vn_encode_VkFlags(enc, &val->sampledImageStencilSampleCounts);
121 vn_encode_VkFlags(enc, &val->storageImageSampleCounts);
122 vn_encode_uint32_t(enc, &val->maxSampleMaskWords);
123 vn_encode_VkBool32(enc, &val->timestampComputeAndGraphics);
124 vn_encode_float(enc, &val->timestampPeriod);
125 vn_encode_uint32_t(enc, &val->maxClipDistances);
126 vn_encode_uint32_t(enc, &val->maxCullDistances);
127 vn_encode_uint32_t(enc, &val->maxCombinedClipAndCullDistances);
128 vn_encode_uint32_t(enc, &val->discreteQueuePriorities);
129 vn_encode_array_size(enc, 2);
130 vn_encode_float_array(enc, val->pointSizeRange, 2);
131 vn_encode_array_size(enc, 2);
132 vn_encode_float_array(enc, val->lineWidthRange, 2);
133 vn_encode_float(enc, &val->pointSizeGranularity);
134 vn_encode_float(enc, &val->lineWidthGranularity);
135 vn_encode_VkBool32(enc, &val->strictLines);
136 vn_encode_VkBool32(enc, &val->standardSampleLocations);
137 vn_encode_VkDeviceSize(enc, &val->optimalBufferCopyOffsetAlignment);
138 vn_encode_VkDeviceSize(enc, &val->optimalBufferCopyRowPitchAlignment);
139 vn_encode_VkDeviceSize(enc, &val->nonCoherentAtomSize);
140 }
141
142 static inline void
vn_decode_VkPhysicalDeviceLimits_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceLimits * val)143 vn_decode_VkPhysicalDeviceLimits_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceLimits *val)
144 {
145 /* skip val->maxImageDimension1D */
146 /* skip val->maxImageDimension2D */
147 /* skip val->maxImageDimension3D */
148 /* skip val->maxImageDimensionCube */
149 /* skip val->maxImageArrayLayers */
150 /* skip val->maxTexelBufferElements */
151 /* skip val->maxUniformBufferRange */
152 /* skip val->maxStorageBufferRange */
153 /* skip val->maxPushConstantsSize */
154 /* skip val->maxMemoryAllocationCount */
155 /* skip val->maxSamplerAllocationCount */
156 /* skip val->bufferImageGranularity */
157 /* skip val->sparseAddressSpaceSize */
158 /* skip val->maxBoundDescriptorSets */
159 /* skip val->maxPerStageDescriptorSamplers */
160 /* skip val->maxPerStageDescriptorUniformBuffers */
161 /* skip val->maxPerStageDescriptorStorageBuffers */
162 /* skip val->maxPerStageDescriptorSampledImages */
163 /* skip val->maxPerStageDescriptorStorageImages */
164 /* skip val->maxPerStageDescriptorInputAttachments */
165 /* skip val->maxPerStageResources */
166 /* skip val->maxDescriptorSetSamplers */
167 /* skip val->maxDescriptorSetUniformBuffers */
168 /* skip val->maxDescriptorSetUniformBuffersDynamic */
169 /* skip val->maxDescriptorSetStorageBuffers */
170 /* skip val->maxDescriptorSetStorageBuffersDynamic */
171 /* skip val->maxDescriptorSetSampledImages */
172 /* skip val->maxDescriptorSetStorageImages */
173 /* skip val->maxDescriptorSetInputAttachments */
174 /* skip val->maxVertexInputAttributes */
175 /* skip val->maxVertexInputBindings */
176 /* skip val->maxVertexInputAttributeOffset */
177 /* skip val->maxVertexInputBindingStride */
178 /* skip val->maxVertexOutputComponents */
179 /* skip val->maxTessellationGenerationLevel */
180 /* skip val->maxTessellationPatchSize */
181 /* skip val->maxTessellationControlPerVertexInputComponents */
182 /* skip val->maxTessellationControlPerVertexOutputComponents */
183 /* skip val->maxTessellationControlPerPatchOutputComponents */
184 /* skip val->maxTessellationControlTotalOutputComponents */
185 /* skip val->maxTessellationEvaluationInputComponents */
186 /* skip val->maxTessellationEvaluationOutputComponents */
187 /* skip val->maxGeometryShaderInvocations */
188 /* skip val->maxGeometryInputComponents */
189 /* skip val->maxGeometryOutputComponents */
190 /* skip val->maxGeometryOutputVertices */
191 /* skip val->maxGeometryTotalOutputComponents */
192 /* skip val->maxFragmentInputComponents */
193 /* skip val->maxFragmentOutputAttachments */
194 /* skip val->maxFragmentDualSrcAttachments */
195 /* skip val->maxFragmentCombinedOutputResources */
196 /* skip val->maxComputeSharedMemorySize */
197 /* skip val->maxComputeWorkGroupCount */
198 /* skip val->maxComputeWorkGroupInvocations */
199 /* skip val->maxComputeWorkGroupSize */
200 /* skip val->subPixelPrecisionBits */
201 /* skip val->subTexelPrecisionBits */
202 /* skip val->mipmapPrecisionBits */
203 /* skip val->maxDrawIndexedIndexValue */
204 /* skip val->maxDrawIndirectCount */
205 /* skip val->maxSamplerLodBias */
206 /* skip val->maxSamplerAnisotropy */
207 /* skip val->maxViewports */
208 /* skip val->maxViewportDimensions */
209 /* skip val->viewportBoundsRange */
210 /* skip val->viewportSubPixelBits */
211 /* skip val->minMemoryMapAlignment */
212 /* skip val->minTexelBufferOffsetAlignment */
213 /* skip val->minUniformBufferOffsetAlignment */
214 /* skip val->minStorageBufferOffsetAlignment */
215 /* skip val->minTexelOffset */
216 /* skip val->maxTexelOffset */
217 /* skip val->minTexelGatherOffset */
218 /* skip val->maxTexelGatherOffset */
219 /* skip val->minInterpolationOffset */
220 /* skip val->maxInterpolationOffset */
221 /* skip val->subPixelInterpolationOffsetBits */
222 /* skip val->maxFramebufferWidth */
223 /* skip val->maxFramebufferHeight */
224 /* skip val->maxFramebufferLayers */
225 /* skip val->framebufferColorSampleCounts */
226 /* skip val->framebufferDepthSampleCounts */
227 /* skip val->framebufferStencilSampleCounts */
228 /* skip val->framebufferNoAttachmentsSampleCounts */
229 /* skip val->maxColorAttachments */
230 /* skip val->sampledImageColorSampleCounts */
231 /* skip val->sampledImageIntegerSampleCounts */
232 /* skip val->sampledImageDepthSampleCounts */
233 /* skip val->sampledImageStencilSampleCounts */
234 /* skip val->storageImageSampleCounts */
235 /* skip val->maxSampleMaskWords */
236 /* skip val->timestampComputeAndGraphics */
237 /* skip val->timestampPeriod */
238 /* skip val->maxClipDistances */
239 /* skip val->maxCullDistances */
240 /* skip val->maxCombinedClipAndCullDistances */
241 /* skip val->discreteQueuePriorities */
242 /* skip val->pointSizeRange */
243 /* skip val->lineWidthRange */
244 /* skip val->pointSizeGranularity */
245 /* skip val->lineWidthGranularity */
246 /* skip val->strictLines */
247 /* skip val->standardSampleLocations */
248 /* skip val->optimalBufferCopyOffsetAlignment */
249 /* skip val->optimalBufferCopyRowPitchAlignment */
250 /* skip val->nonCoherentAtomSize */
251 }
252
253 /* struct VkPhysicalDeviceSparseProperties */
254
255 static inline void
vn_encode_VkPhysicalDeviceSparseProperties(struct vn_cs_encoder * enc,const VkPhysicalDeviceSparseProperties * val)256 vn_encode_VkPhysicalDeviceSparseProperties(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseProperties *val)
257 {
258 vn_encode_VkBool32(enc, &val->residencyStandard2DBlockShape);
259 vn_encode_VkBool32(enc, &val->residencyStandard2DMultisampleBlockShape);
260 vn_encode_VkBool32(enc, &val->residencyStandard3DBlockShape);
261 vn_encode_VkBool32(enc, &val->residencyAlignedMipSize);
262 vn_encode_VkBool32(enc, &val->residencyNonResidentStrict);
263 }
264
265 static inline void
vn_decode_VkPhysicalDeviceSparseProperties_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceSparseProperties * val)266 vn_decode_VkPhysicalDeviceSparseProperties_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceSparseProperties *val)
267 {
268 /* skip val->residencyStandard2DBlockShape */
269 /* skip val->residencyStandard2DMultisampleBlockShape */
270 /* skip val->residencyStandard3DBlockShape */
271 /* skip val->residencyAlignedMipSize */
272 /* skip val->residencyNonResidentStrict */
273 }
274
275 /* struct VkPhysicalDeviceProperties */
276
277 static inline void
vn_encode_VkPhysicalDeviceProperties(struct vn_cs_encoder * enc,const VkPhysicalDeviceProperties * val)278 vn_encode_VkPhysicalDeviceProperties(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties *val)
279 {
280 vn_encode_uint32_t(enc, &val->apiVersion);
281 vn_encode_uint32_t(enc, &val->driverVersion);
282 vn_encode_uint32_t(enc, &val->vendorID);
283 vn_encode_uint32_t(enc, &val->deviceID);
284 vn_encode_VkPhysicalDeviceType(enc, &val->deviceType);
285 vn_encode_array_size(enc, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
286 vn_encode_char_array(enc, val->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
287 vn_encode_array_size(enc, VK_UUID_SIZE);
288 vn_encode_uint8_t_array(enc, val->pipelineCacheUUID, VK_UUID_SIZE);
289 vn_encode_VkPhysicalDeviceLimits(enc, &val->limits);
290 vn_encode_VkPhysicalDeviceSparseProperties(enc, &val->sparseProperties);
291 }
292
293 static inline void
vn_decode_VkPhysicalDeviceProperties_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceProperties * val)294 vn_decode_VkPhysicalDeviceProperties_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties *val)
295 {
296 /* skip val->apiVersion */
297 /* skip val->driverVersion */
298 /* skip val->vendorID */
299 /* skip val->deviceID */
300 /* skip val->deviceType */
301 /* skip val->deviceName */
302 /* skip val->pipelineCacheUUID */
303 vn_decode_VkPhysicalDeviceLimits_partial_temp(dec, &val->limits);
304 vn_decode_VkPhysicalDeviceSparseProperties_partial_temp(dec, &val->sparseProperties);
305 }
306
307 /* struct VkQueueFamilyProperties */
308
309 static inline void
vn_encode_VkQueueFamilyProperties(struct vn_cs_encoder * enc,const VkQueueFamilyProperties * val)310 vn_encode_VkQueueFamilyProperties(struct vn_cs_encoder *enc, const VkQueueFamilyProperties *val)
311 {
312 vn_encode_VkFlags(enc, &val->queueFlags);
313 vn_encode_uint32_t(enc, &val->queueCount);
314 vn_encode_uint32_t(enc, &val->timestampValidBits);
315 vn_encode_VkExtent3D(enc, &val->minImageTransferGranularity);
316 }
317
318 static inline void
vn_decode_VkQueueFamilyProperties_partial_temp(struct vn_cs_decoder * dec,VkQueueFamilyProperties * val)319 vn_decode_VkQueueFamilyProperties_partial_temp(struct vn_cs_decoder *dec, VkQueueFamilyProperties *val)
320 {
321 /* skip val->queueFlags */
322 /* skip val->queueCount */
323 /* skip val->timestampValidBits */
324 vn_decode_VkExtent3D_partial_temp(dec, &val->minImageTransferGranularity);
325 }
326
327 /* struct VkMemoryType */
328
329 static inline void
vn_encode_VkMemoryType(struct vn_cs_encoder * enc,const VkMemoryType * val)330 vn_encode_VkMemoryType(struct vn_cs_encoder *enc, const VkMemoryType *val)
331 {
332 vn_encode_VkFlags(enc, &val->propertyFlags);
333 vn_encode_uint32_t(enc, &val->heapIndex);
334 }
335
336 static inline void
vn_decode_VkMemoryType_partial_temp(struct vn_cs_decoder * dec,VkMemoryType * val)337 vn_decode_VkMemoryType_partial_temp(struct vn_cs_decoder *dec, VkMemoryType *val)
338 {
339 /* skip val->propertyFlags */
340 /* skip val->heapIndex */
341 }
342
343 /* struct VkMemoryHeap */
344
345 static inline void
vn_encode_VkMemoryHeap(struct vn_cs_encoder * enc,const VkMemoryHeap * val)346 vn_encode_VkMemoryHeap(struct vn_cs_encoder *enc, const VkMemoryHeap *val)
347 {
348 vn_encode_VkDeviceSize(enc, &val->size);
349 vn_encode_VkFlags(enc, &val->flags);
350 }
351
352 static inline void
vn_decode_VkMemoryHeap_partial_temp(struct vn_cs_decoder * dec,VkMemoryHeap * val)353 vn_decode_VkMemoryHeap_partial_temp(struct vn_cs_decoder *dec, VkMemoryHeap *val)
354 {
355 /* skip val->size */
356 /* skip val->flags */
357 }
358
359 /* struct VkPhysicalDeviceMemoryProperties */
360
361 static inline void
vn_encode_VkPhysicalDeviceMemoryProperties(struct vn_cs_encoder * enc,const VkPhysicalDeviceMemoryProperties * val)362 vn_encode_VkPhysicalDeviceMemoryProperties(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties *val)
363 {
364 vn_encode_uint32_t(enc, &val->memoryTypeCount);
365 vn_encode_array_size(enc, VK_MAX_MEMORY_TYPES);
366 for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++)
367 vn_encode_VkMemoryType(enc, &val->memoryTypes[i]);
368 vn_encode_uint32_t(enc, &val->memoryHeapCount);
369 vn_encode_array_size(enc, VK_MAX_MEMORY_HEAPS);
370 for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
371 vn_encode_VkMemoryHeap(enc, &val->memoryHeaps[i]);
372 }
373
374 static inline void
vn_decode_VkPhysicalDeviceMemoryProperties_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceMemoryProperties * val)375 vn_decode_VkPhysicalDeviceMemoryProperties_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties *val)
376 {
377 /* skip val->memoryTypeCount */
378 {
379 const uint32_t iter_count = vn_decode_array_size(dec, VK_MAX_MEMORY_TYPES);
380 for (uint32_t i = 0; i < iter_count; i++)
381 vn_decode_VkMemoryType_partial_temp(dec, &val->memoryTypes[i]);
382 }
383 /* skip val->memoryHeapCount */
384 {
385 const uint32_t iter_count = vn_decode_array_size(dec, VK_MAX_MEMORY_HEAPS);
386 for (uint32_t i = 0; i < iter_count; i++)
387 vn_decode_VkMemoryHeap_partial_temp(dec, &val->memoryHeaps[i]);
388 }
389 }
390
391 /* struct VkPhysicalDeviceFeatures */
392
393 static inline void
vn_encode_VkPhysicalDeviceFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures * val)394 vn_encode_VkPhysicalDeviceFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures *val)
395 {
396 vn_encode_VkBool32(enc, &val->robustBufferAccess);
397 vn_encode_VkBool32(enc, &val->fullDrawIndexUint32);
398 vn_encode_VkBool32(enc, &val->imageCubeArray);
399 vn_encode_VkBool32(enc, &val->independentBlend);
400 vn_encode_VkBool32(enc, &val->geometryShader);
401 vn_encode_VkBool32(enc, &val->tessellationShader);
402 vn_encode_VkBool32(enc, &val->sampleRateShading);
403 vn_encode_VkBool32(enc, &val->dualSrcBlend);
404 vn_encode_VkBool32(enc, &val->logicOp);
405 vn_encode_VkBool32(enc, &val->multiDrawIndirect);
406 vn_encode_VkBool32(enc, &val->drawIndirectFirstInstance);
407 vn_encode_VkBool32(enc, &val->depthClamp);
408 vn_encode_VkBool32(enc, &val->depthBiasClamp);
409 vn_encode_VkBool32(enc, &val->fillModeNonSolid);
410 vn_encode_VkBool32(enc, &val->depthBounds);
411 vn_encode_VkBool32(enc, &val->wideLines);
412 vn_encode_VkBool32(enc, &val->largePoints);
413 vn_encode_VkBool32(enc, &val->alphaToOne);
414 vn_encode_VkBool32(enc, &val->multiViewport);
415 vn_encode_VkBool32(enc, &val->samplerAnisotropy);
416 vn_encode_VkBool32(enc, &val->textureCompressionETC2);
417 vn_encode_VkBool32(enc, &val->textureCompressionASTC_LDR);
418 vn_encode_VkBool32(enc, &val->textureCompressionBC);
419 vn_encode_VkBool32(enc, &val->occlusionQueryPrecise);
420 vn_encode_VkBool32(enc, &val->pipelineStatisticsQuery);
421 vn_encode_VkBool32(enc, &val->vertexPipelineStoresAndAtomics);
422 vn_encode_VkBool32(enc, &val->fragmentStoresAndAtomics);
423 vn_encode_VkBool32(enc, &val->shaderTessellationAndGeometryPointSize);
424 vn_encode_VkBool32(enc, &val->shaderImageGatherExtended);
425 vn_encode_VkBool32(enc, &val->shaderStorageImageExtendedFormats);
426 vn_encode_VkBool32(enc, &val->shaderStorageImageMultisample);
427 vn_encode_VkBool32(enc, &val->shaderStorageImageReadWithoutFormat);
428 vn_encode_VkBool32(enc, &val->shaderStorageImageWriteWithoutFormat);
429 vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayDynamicIndexing);
430 vn_encode_VkBool32(enc, &val->shaderSampledImageArrayDynamicIndexing);
431 vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayDynamicIndexing);
432 vn_encode_VkBool32(enc, &val->shaderStorageImageArrayDynamicIndexing);
433 vn_encode_VkBool32(enc, &val->shaderClipDistance);
434 vn_encode_VkBool32(enc, &val->shaderCullDistance);
435 vn_encode_VkBool32(enc, &val->shaderFloat64);
436 vn_encode_VkBool32(enc, &val->shaderInt64);
437 vn_encode_VkBool32(enc, &val->shaderInt16);
438 vn_encode_VkBool32(enc, &val->shaderResourceResidency);
439 vn_encode_VkBool32(enc, &val->shaderResourceMinLod);
440 vn_encode_VkBool32(enc, &val->sparseBinding);
441 vn_encode_VkBool32(enc, &val->sparseResidencyBuffer);
442 vn_encode_VkBool32(enc, &val->sparseResidencyImage2D);
443 vn_encode_VkBool32(enc, &val->sparseResidencyImage3D);
444 vn_encode_VkBool32(enc, &val->sparseResidency2Samples);
445 vn_encode_VkBool32(enc, &val->sparseResidency4Samples);
446 vn_encode_VkBool32(enc, &val->sparseResidency8Samples);
447 vn_encode_VkBool32(enc, &val->sparseResidency16Samples);
448 vn_encode_VkBool32(enc, &val->sparseResidencyAliased);
449 vn_encode_VkBool32(enc, &val->variableMultisampleRate);
450 vn_encode_VkBool32(enc, &val->inheritedQueries);
451 }
452
453 static inline void
vn_decode_VkPhysicalDeviceFeatures_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceFeatures * val)454 vn_decode_VkPhysicalDeviceFeatures_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures *val)
455 {
456 vn_decode_VkBool32(dec, &val->robustBufferAccess);
457 vn_decode_VkBool32(dec, &val->fullDrawIndexUint32);
458 vn_decode_VkBool32(dec, &val->imageCubeArray);
459 vn_decode_VkBool32(dec, &val->independentBlend);
460 vn_decode_VkBool32(dec, &val->geometryShader);
461 vn_decode_VkBool32(dec, &val->tessellationShader);
462 vn_decode_VkBool32(dec, &val->sampleRateShading);
463 vn_decode_VkBool32(dec, &val->dualSrcBlend);
464 vn_decode_VkBool32(dec, &val->logicOp);
465 vn_decode_VkBool32(dec, &val->multiDrawIndirect);
466 vn_decode_VkBool32(dec, &val->drawIndirectFirstInstance);
467 vn_decode_VkBool32(dec, &val->depthClamp);
468 vn_decode_VkBool32(dec, &val->depthBiasClamp);
469 vn_decode_VkBool32(dec, &val->fillModeNonSolid);
470 vn_decode_VkBool32(dec, &val->depthBounds);
471 vn_decode_VkBool32(dec, &val->wideLines);
472 vn_decode_VkBool32(dec, &val->largePoints);
473 vn_decode_VkBool32(dec, &val->alphaToOne);
474 vn_decode_VkBool32(dec, &val->multiViewport);
475 vn_decode_VkBool32(dec, &val->samplerAnisotropy);
476 vn_decode_VkBool32(dec, &val->textureCompressionETC2);
477 vn_decode_VkBool32(dec, &val->textureCompressionASTC_LDR);
478 vn_decode_VkBool32(dec, &val->textureCompressionBC);
479 vn_decode_VkBool32(dec, &val->occlusionQueryPrecise);
480 vn_decode_VkBool32(dec, &val->pipelineStatisticsQuery);
481 vn_decode_VkBool32(dec, &val->vertexPipelineStoresAndAtomics);
482 vn_decode_VkBool32(dec, &val->fragmentStoresAndAtomics);
483 vn_decode_VkBool32(dec, &val->shaderTessellationAndGeometryPointSize);
484 vn_decode_VkBool32(dec, &val->shaderImageGatherExtended);
485 vn_decode_VkBool32(dec, &val->shaderStorageImageExtendedFormats);
486 vn_decode_VkBool32(dec, &val->shaderStorageImageMultisample);
487 vn_decode_VkBool32(dec, &val->shaderStorageImageReadWithoutFormat);
488 vn_decode_VkBool32(dec, &val->shaderStorageImageWriteWithoutFormat);
489 vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayDynamicIndexing);
490 vn_decode_VkBool32(dec, &val->shaderSampledImageArrayDynamicIndexing);
491 vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayDynamicIndexing);
492 vn_decode_VkBool32(dec, &val->shaderStorageImageArrayDynamicIndexing);
493 vn_decode_VkBool32(dec, &val->shaderClipDistance);
494 vn_decode_VkBool32(dec, &val->shaderCullDistance);
495 vn_decode_VkBool32(dec, &val->shaderFloat64);
496 vn_decode_VkBool32(dec, &val->shaderInt64);
497 vn_decode_VkBool32(dec, &val->shaderInt16);
498 vn_decode_VkBool32(dec, &val->shaderResourceResidency);
499 vn_decode_VkBool32(dec, &val->shaderResourceMinLod);
500 vn_decode_VkBool32(dec, &val->sparseBinding);
501 vn_decode_VkBool32(dec, &val->sparseResidencyBuffer);
502 vn_decode_VkBool32(dec, &val->sparseResidencyImage2D);
503 vn_decode_VkBool32(dec, &val->sparseResidencyImage3D);
504 vn_decode_VkBool32(dec, &val->sparseResidency2Samples);
505 vn_decode_VkBool32(dec, &val->sparseResidency4Samples);
506 vn_decode_VkBool32(dec, &val->sparseResidency8Samples);
507 vn_decode_VkBool32(dec, &val->sparseResidency16Samples);
508 vn_decode_VkBool32(dec, &val->sparseResidencyAliased);
509 vn_decode_VkBool32(dec, &val->variableMultisampleRate);
510 vn_decode_VkBool32(dec, &val->inheritedQueries);
511 }
512
513 static inline void
vn_decode_VkPhysicalDeviceFeatures_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceFeatures * val)514 vn_decode_VkPhysicalDeviceFeatures_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures *val)
515 {
516 /* skip val->robustBufferAccess */
517 /* skip val->fullDrawIndexUint32 */
518 /* skip val->imageCubeArray */
519 /* skip val->independentBlend */
520 /* skip val->geometryShader */
521 /* skip val->tessellationShader */
522 /* skip val->sampleRateShading */
523 /* skip val->dualSrcBlend */
524 /* skip val->logicOp */
525 /* skip val->multiDrawIndirect */
526 /* skip val->drawIndirectFirstInstance */
527 /* skip val->depthClamp */
528 /* skip val->depthBiasClamp */
529 /* skip val->fillModeNonSolid */
530 /* skip val->depthBounds */
531 /* skip val->wideLines */
532 /* skip val->largePoints */
533 /* skip val->alphaToOne */
534 /* skip val->multiViewport */
535 /* skip val->samplerAnisotropy */
536 /* skip val->textureCompressionETC2 */
537 /* skip val->textureCompressionASTC_LDR */
538 /* skip val->textureCompressionBC */
539 /* skip val->occlusionQueryPrecise */
540 /* skip val->pipelineStatisticsQuery */
541 /* skip val->vertexPipelineStoresAndAtomics */
542 /* skip val->fragmentStoresAndAtomics */
543 /* skip val->shaderTessellationAndGeometryPointSize */
544 /* skip val->shaderImageGatherExtended */
545 /* skip val->shaderStorageImageExtendedFormats */
546 /* skip val->shaderStorageImageMultisample */
547 /* skip val->shaderStorageImageReadWithoutFormat */
548 /* skip val->shaderStorageImageWriteWithoutFormat */
549 /* skip val->shaderUniformBufferArrayDynamicIndexing */
550 /* skip val->shaderSampledImageArrayDynamicIndexing */
551 /* skip val->shaderStorageBufferArrayDynamicIndexing */
552 /* skip val->shaderStorageImageArrayDynamicIndexing */
553 /* skip val->shaderClipDistance */
554 /* skip val->shaderCullDistance */
555 /* skip val->shaderFloat64 */
556 /* skip val->shaderInt64 */
557 /* skip val->shaderInt16 */
558 /* skip val->shaderResourceResidency */
559 /* skip val->shaderResourceMinLod */
560 /* skip val->sparseBinding */
561 /* skip val->sparseResidencyBuffer */
562 /* skip val->sparseResidencyImage2D */
563 /* skip val->sparseResidencyImage3D */
564 /* skip val->sparseResidency2Samples */
565 /* skip val->sparseResidency4Samples */
566 /* skip val->sparseResidency8Samples */
567 /* skip val->sparseResidency16Samples */
568 /* skip val->sparseResidencyAliased */
569 /* skip val->variableMultisampleRate */
570 /* skip val->inheritedQueries */
571 }
572
573 static inline void
vn_replace_VkPhysicalDeviceFeatures_handle(VkPhysicalDeviceFeatures * val)574 vn_replace_VkPhysicalDeviceFeatures_handle(VkPhysicalDeviceFeatures *val)
575 {
576 /* skip val->robustBufferAccess */
577 /* skip val->fullDrawIndexUint32 */
578 /* skip val->imageCubeArray */
579 /* skip val->independentBlend */
580 /* skip val->geometryShader */
581 /* skip val->tessellationShader */
582 /* skip val->sampleRateShading */
583 /* skip val->dualSrcBlend */
584 /* skip val->logicOp */
585 /* skip val->multiDrawIndirect */
586 /* skip val->drawIndirectFirstInstance */
587 /* skip val->depthClamp */
588 /* skip val->depthBiasClamp */
589 /* skip val->fillModeNonSolid */
590 /* skip val->depthBounds */
591 /* skip val->wideLines */
592 /* skip val->largePoints */
593 /* skip val->alphaToOne */
594 /* skip val->multiViewport */
595 /* skip val->samplerAnisotropy */
596 /* skip val->textureCompressionETC2 */
597 /* skip val->textureCompressionASTC_LDR */
598 /* skip val->textureCompressionBC */
599 /* skip val->occlusionQueryPrecise */
600 /* skip val->pipelineStatisticsQuery */
601 /* skip val->vertexPipelineStoresAndAtomics */
602 /* skip val->fragmentStoresAndAtomics */
603 /* skip val->shaderTessellationAndGeometryPointSize */
604 /* skip val->shaderImageGatherExtended */
605 /* skip val->shaderStorageImageExtendedFormats */
606 /* skip val->shaderStorageImageMultisample */
607 /* skip val->shaderStorageImageReadWithoutFormat */
608 /* skip val->shaderStorageImageWriteWithoutFormat */
609 /* skip val->shaderUniformBufferArrayDynamicIndexing */
610 /* skip val->shaderSampledImageArrayDynamicIndexing */
611 /* skip val->shaderStorageBufferArrayDynamicIndexing */
612 /* skip val->shaderStorageImageArrayDynamicIndexing */
613 /* skip val->shaderClipDistance */
614 /* skip val->shaderCullDistance */
615 /* skip val->shaderFloat64 */
616 /* skip val->shaderInt64 */
617 /* skip val->shaderInt16 */
618 /* skip val->shaderResourceResidency */
619 /* skip val->shaderResourceMinLod */
620 /* skip val->sparseBinding */
621 /* skip val->sparseResidencyBuffer */
622 /* skip val->sparseResidencyImage2D */
623 /* skip val->sparseResidencyImage3D */
624 /* skip val->sparseResidency2Samples */
625 /* skip val->sparseResidency4Samples */
626 /* skip val->sparseResidency8Samples */
627 /* skip val->sparseResidency16Samples */
628 /* skip val->sparseResidencyAliased */
629 /* skip val->variableMultisampleRate */
630 /* skip val->inheritedQueries */
631 }
632
633 /* struct VkFormatProperties */
634
635 static inline void
vn_encode_VkFormatProperties(struct vn_cs_encoder * enc,const VkFormatProperties * val)636 vn_encode_VkFormatProperties(struct vn_cs_encoder *enc, const VkFormatProperties *val)
637 {
638 vn_encode_VkFlags(enc, &val->linearTilingFeatures);
639 vn_encode_VkFlags(enc, &val->optimalTilingFeatures);
640 vn_encode_VkFlags(enc, &val->bufferFeatures);
641 }
642
643 static inline void
vn_decode_VkFormatProperties_partial_temp(struct vn_cs_decoder * dec,VkFormatProperties * val)644 vn_decode_VkFormatProperties_partial_temp(struct vn_cs_decoder *dec, VkFormatProperties *val)
645 {
646 /* skip val->linearTilingFeatures */
647 /* skip val->optimalTilingFeatures */
648 /* skip val->bufferFeatures */
649 }
650
651 /* struct VkImageFormatProperties */
652
653 static inline void
vn_encode_VkImageFormatProperties(struct vn_cs_encoder * enc,const VkImageFormatProperties * val)654 vn_encode_VkImageFormatProperties(struct vn_cs_encoder *enc, const VkImageFormatProperties *val)
655 {
656 vn_encode_VkExtent3D(enc, &val->maxExtent);
657 vn_encode_uint32_t(enc, &val->maxMipLevels);
658 vn_encode_uint32_t(enc, &val->maxArrayLayers);
659 vn_encode_VkFlags(enc, &val->sampleCounts);
660 vn_encode_VkDeviceSize(enc, &val->maxResourceSize);
661 }
662
663 static inline void
vn_decode_VkImageFormatProperties_partial_temp(struct vn_cs_decoder * dec,VkImageFormatProperties * val)664 vn_decode_VkImageFormatProperties_partial_temp(struct vn_cs_decoder *dec, VkImageFormatProperties *val)
665 {
666 vn_decode_VkExtent3D_partial_temp(dec, &val->maxExtent);
667 /* skip val->maxMipLevels */
668 /* skip val->maxArrayLayers */
669 /* skip val->sampleCounts */
670 /* skip val->maxResourceSize */
671 }
672
673 /* struct VkDeviceQueueCreateInfo chain */
674
675 static inline void *
vn_decode_VkDeviceQueueCreateInfo_pnext_temp(struct vn_cs_decoder * dec)676 vn_decode_VkDeviceQueueCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
677 {
678 /* no known/supported struct */
679 if (vn_decode_simple_pointer(dec))
680 vn_cs_decoder_set_fatal(dec);
681 return NULL;
682 }
683
684 static inline void
vn_decode_VkDeviceQueueCreateInfo_self_temp(struct vn_cs_decoder * dec,VkDeviceQueueCreateInfo * val)685 vn_decode_VkDeviceQueueCreateInfo_self_temp(struct vn_cs_decoder *dec, VkDeviceQueueCreateInfo *val)
686 {
687 /* skip val->{sType,pNext} */
688 vn_decode_VkFlags(dec, &val->flags);
689 vn_decode_uint32_t(dec, &val->queueFamilyIndex);
690 vn_decode_uint32_t(dec, &val->queueCount);
691 if (vn_peek_array_size(dec)) {
692 const size_t array_size = vn_decode_array_size(dec, val->queueCount);
693 val->pQueuePriorities = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pQueuePriorities) * array_size);
694 if (!val->pQueuePriorities) return;
695 vn_decode_float_array(dec, (float *)val->pQueuePriorities, array_size);
696 } else {
697 vn_decode_array_size(dec, val->queueCount);
698 val->pQueuePriorities = NULL;
699 }
700 }
701
702 static inline void
vn_decode_VkDeviceQueueCreateInfo_temp(struct vn_cs_decoder * dec,VkDeviceQueueCreateInfo * val)703 vn_decode_VkDeviceQueueCreateInfo_temp(struct vn_cs_decoder *dec, VkDeviceQueueCreateInfo *val)
704 {
705 VkStructureType stype;
706 vn_decode_VkStructureType(dec, &stype);
707 if (stype != VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO)
708 vn_cs_decoder_set_fatal(dec);
709
710 val->sType = stype;
711 val->pNext = vn_decode_VkDeviceQueueCreateInfo_pnext_temp(dec);
712 vn_decode_VkDeviceQueueCreateInfo_self_temp(dec, val);
713 }
714
715 static inline void
vn_replace_VkDeviceQueueCreateInfo_handle_self(VkDeviceQueueCreateInfo * val)716 vn_replace_VkDeviceQueueCreateInfo_handle_self(VkDeviceQueueCreateInfo *val)
717 {
718 /* skip val->sType */
719 /* skip val->pNext */
720 /* skip val->flags */
721 /* skip val->queueFamilyIndex */
722 /* skip val->queueCount */
723 /* skip val->pQueuePriorities */
724 }
725
726 static inline void
vn_replace_VkDeviceQueueCreateInfo_handle(VkDeviceQueueCreateInfo * val)727 vn_replace_VkDeviceQueueCreateInfo_handle(VkDeviceQueueCreateInfo *val)
728 {
729 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
730
731 do {
732 switch ((int32_t)pnext->sType) {
733 case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO:
734 vn_replace_VkDeviceQueueCreateInfo_handle_self((VkDeviceQueueCreateInfo *)pnext);
735 break;
736 default:
737 /* ignore unknown/unsupported struct */
738 break;
739 }
740 pnext = pnext->pNext;
741 } while (pnext);
742 }
743
744 /* struct VkPhysicalDeviceVariablePointersFeatures chain */
745
746 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_encoder * enc,const void * val)747 vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
748 {
749 /* no known/supported struct */
750 vn_encode_simple_pointer(enc, NULL);
751 }
752
753 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVariablePointersFeatures * val)754 vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
755 {
756 /* skip val->{sType,pNext} */
757 vn_encode_VkBool32(enc, &val->variablePointersStorageBuffer);
758 vn_encode_VkBool32(enc, &val->variablePointers);
759 }
760
761 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceVariablePointersFeatures * val)762 vn_encode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
763 {
764 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
765 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES });
766 vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext(enc, val->pNext);
767 vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, val);
768 }
769
770 static inline void *
vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext_temp(struct vn_cs_decoder * dec)771 vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext_temp(struct vn_cs_decoder *dec)
772 {
773 /* no known/supported struct */
774 if (vn_decode_simple_pointer(dec))
775 vn_cs_decoder_set_fatal(dec);
776 return NULL;
777 }
778
779 static inline void
vn_decode_VkPhysicalDeviceVariablePointersFeatures_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVariablePointersFeatures * val)780 vn_decode_VkPhysicalDeviceVariablePointersFeatures_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVariablePointersFeatures *val)
781 {
782 /* skip val->{sType,pNext} */
783 vn_decode_VkBool32(dec, &val->variablePointersStorageBuffer);
784 vn_decode_VkBool32(dec, &val->variablePointers);
785 }
786
787 static inline void
vn_decode_VkPhysicalDeviceVariablePointersFeatures_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVariablePointersFeatures * val)788 vn_decode_VkPhysicalDeviceVariablePointersFeatures_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVariablePointersFeatures *val)
789 {
790 VkStructureType stype;
791 vn_decode_VkStructureType(dec, &stype);
792 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES)
793 vn_cs_decoder_set_fatal(dec);
794
795 val->sType = stype;
796 val->pNext = vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext_temp(dec);
797 vn_decode_VkPhysicalDeviceVariablePointersFeatures_self_temp(dec, val);
798 }
799
800 static inline void *
vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext_partial_temp(struct vn_cs_decoder * dec)801 vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext_partial_temp(struct vn_cs_decoder *dec)
802 {
803 /* no known/supported struct */
804 if (vn_decode_simple_pointer(dec))
805 vn_cs_decoder_set_fatal(dec);
806 return NULL;
807 }
808
809 static inline void
vn_decode_VkPhysicalDeviceVariablePointersFeatures_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVariablePointersFeatures * val)810 vn_decode_VkPhysicalDeviceVariablePointersFeatures_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVariablePointersFeatures *val)
811 {
812 /* skip val->{sType,pNext} */
813 /* skip val->variablePointersStorageBuffer */
814 /* skip val->variablePointers */
815 }
816
817 static inline void
vn_decode_VkPhysicalDeviceVariablePointersFeatures_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVariablePointersFeatures * val)818 vn_decode_VkPhysicalDeviceVariablePointersFeatures_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVariablePointersFeatures *val)
819 {
820 VkStructureType stype;
821 vn_decode_VkStructureType(dec, &stype);
822 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES)
823 vn_cs_decoder_set_fatal(dec);
824
825 val->sType = stype;
826 val->pNext = vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext_partial_temp(dec);
827 vn_decode_VkPhysicalDeviceVariablePointersFeatures_self_partial_temp(dec, val);
828 }
829
830 static inline void
vn_replace_VkPhysicalDeviceVariablePointersFeatures_handle_self(VkPhysicalDeviceVariablePointersFeatures * val)831 vn_replace_VkPhysicalDeviceVariablePointersFeatures_handle_self(VkPhysicalDeviceVariablePointersFeatures *val)
832 {
833 /* skip val->sType */
834 /* skip val->pNext */
835 /* skip val->variablePointersStorageBuffer */
836 /* skip val->variablePointers */
837 }
838
839 static inline void
vn_replace_VkPhysicalDeviceVariablePointersFeatures_handle(VkPhysicalDeviceVariablePointersFeatures * val)840 vn_replace_VkPhysicalDeviceVariablePointersFeatures_handle(VkPhysicalDeviceVariablePointersFeatures *val)
841 {
842 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
843
844 do {
845 switch ((int32_t)pnext->sType) {
846 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
847 vn_replace_VkPhysicalDeviceVariablePointersFeatures_handle_self((VkPhysicalDeviceVariablePointersFeatures *)pnext);
848 break;
849 default:
850 /* ignore unknown/unsupported struct */
851 break;
852 }
853 pnext = pnext->pNext;
854 } while (pnext);
855 }
856
857 /* struct VkPhysicalDeviceMultiviewFeatures chain */
858
859 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_encoder * enc,const void * val)860 vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
861 {
862 /* no known/supported struct */
863 vn_encode_simple_pointer(enc, NULL);
864 }
865
866 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewFeatures * val)867 vn_encode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
868 {
869 /* skip val->{sType,pNext} */
870 vn_encode_VkBool32(enc, &val->multiview);
871 vn_encode_VkBool32(enc, &val->multiviewGeometryShader);
872 vn_encode_VkBool32(enc, &val->multiviewTessellationShader);
873 }
874
875 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewFeatures * val)876 vn_encode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
877 {
878 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
879 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES });
880 vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext(enc, val->pNext);
881 vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, val);
882 }
883
884 static inline void *
vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext_temp(struct vn_cs_decoder * dec)885 vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext_temp(struct vn_cs_decoder *dec)
886 {
887 /* no known/supported struct */
888 if (vn_decode_simple_pointer(dec))
889 vn_cs_decoder_set_fatal(dec);
890 return NULL;
891 }
892
893 static inline void
vn_decode_VkPhysicalDeviceMultiviewFeatures_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewFeatures * val)894 vn_decode_VkPhysicalDeviceMultiviewFeatures_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewFeatures *val)
895 {
896 /* skip val->{sType,pNext} */
897 vn_decode_VkBool32(dec, &val->multiview);
898 vn_decode_VkBool32(dec, &val->multiviewGeometryShader);
899 vn_decode_VkBool32(dec, &val->multiviewTessellationShader);
900 }
901
902 static inline void
vn_decode_VkPhysicalDeviceMultiviewFeatures_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewFeatures * val)903 vn_decode_VkPhysicalDeviceMultiviewFeatures_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewFeatures *val)
904 {
905 VkStructureType stype;
906 vn_decode_VkStructureType(dec, &stype);
907 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES)
908 vn_cs_decoder_set_fatal(dec);
909
910 val->sType = stype;
911 val->pNext = vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext_temp(dec);
912 vn_decode_VkPhysicalDeviceMultiviewFeatures_self_temp(dec, val);
913 }
914
915 static inline void *
vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext_partial_temp(struct vn_cs_decoder * dec)916 vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext_partial_temp(struct vn_cs_decoder *dec)
917 {
918 /* no known/supported struct */
919 if (vn_decode_simple_pointer(dec))
920 vn_cs_decoder_set_fatal(dec);
921 return NULL;
922 }
923
924 static inline void
vn_decode_VkPhysicalDeviceMultiviewFeatures_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewFeatures * val)925 vn_decode_VkPhysicalDeviceMultiviewFeatures_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewFeatures *val)
926 {
927 /* skip val->{sType,pNext} */
928 /* skip val->multiview */
929 /* skip val->multiviewGeometryShader */
930 /* skip val->multiviewTessellationShader */
931 }
932
933 static inline void
vn_decode_VkPhysicalDeviceMultiviewFeatures_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewFeatures * val)934 vn_decode_VkPhysicalDeviceMultiviewFeatures_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewFeatures *val)
935 {
936 VkStructureType stype;
937 vn_decode_VkStructureType(dec, &stype);
938 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES)
939 vn_cs_decoder_set_fatal(dec);
940
941 val->sType = stype;
942 val->pNext = vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext_partial_temp(dec);
943 vn_decode_VkPhysicalDeviceMultiviewFeatures_self_partial_temp(dec, val);
944 }
945
946 static inline void
vn_replace_VkPhysicalDeviceMultiviewFeatures_handle_self(VkPhysicalDeviceMultiviewFeatures * val)947 vn_replace_VkPhysicalDeviceMultiviewFeatures_handle_self(VkPhysicalDeviceMultiviewFeatures *val)
948 {
949 /* skip val->sType */
950 /* skip val->pNext */
951 /* skip val->multiview */
952 /* skip val->multiviewGeometryShader */
953 /* skip val->multiviewTessellationShader */
954 }
955
956 static inline void
vn_replace_VkPhysicalDeviceMultiviewFeatures_handle(VkPhysicalDeviceMultiviewFeatures * val)957 vn_replace_VkPhysicalDeviceMultiviewFeatures_handle(VkPhysicalDeviceMultiviewFeatures *val)
958 {
959 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
960
961 do {
962 switch ((int32_t)pnext->sType) {
963 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
964 vn_replace_VkPhysicalDeviceMultiviewFeatures_handle_self((VkPhysicalDeviceMultiviewFeatures *)pnext);
965 break;
966 default:
967 /* ignore unknown/unsupported struct */
968 break;
969 }
970 pnext = pnext->pNext;
971 } while (pnext);
972 }
973
974 /* struct VkPhysicalDevice16BitStorageFeatures chain */
975
976 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_encoder * enc,const void * val)977 vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
978 {
979 /* no known/supported struct */
980 vn_encode_simple_pointer(enc, NULL);
981 }
982
983 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDevice16BitStorageFeatures * val)984 vn_encode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
985 {
986 /* skip val->{sType,pNext} */
987 vn_encode_VkBool32(enc, &val->storageBuffer16BitAccess);
988 vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer16BitAccess);
989 vn_encode_VkBool32(enc, &val->storagePushConstant16);
990 vn_encode_VkBool32(enc, &val->storageInputOutput16);
991 }
992
993 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_encoder * enc,const VkPhysicalDevice16BitStorageFeatures * val)994 vn_encode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
995 {
996 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
997 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES });
998 vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext(enc, val->pNext);
999 vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, val);
1000 }
1001
1002 static inline void *
vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext_temp(struct vn_cs_decoder * dec)1003 vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext_temp(struct vn_cs_decoder *dec)
1004 {
1005 /* no known/supported struct */
1006 if (vn_decode_simple_pointer(dec))
1007 vn_cs_decoder_set_fatal(dec);
1008 return NULL;
1009 }
1010
1011 static inline void
vn_decode_VkPhysicalDevice16BitStorageFeatures_self_temp(struct vn_cs_decoder * dec,VkPhysicalDevice16BitStorageFeatures * val)1012 vn_decode_VkPhysicalDevice16BitStorageFeatures_self_temp(struct vn_cs_decoder *dec, VkPhysicalDevice16BitStorageFeatures *val)
1013 {
1014 /* skip val->{sType,pNext} */
1015 vn_decode_VkBool32(dec, &val->storageBuffer16BitAccess);
1016 vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer16BitAccess);
1017 vn_decode_VkBool32(dec, &val->storagePushConstant16);
1018 vn_decode_VkBool32(dec, &val->storageInputOutput16);
1019 }
1020
1021 static inline void
vn_decode_VkPhysicalDevice16BitStorageFeatures_temp(struct vn_cs_decoder * dec,VkPhysicalDevice16BitStorageFeatures * val)1022 vn_decode_VkPhysicalDevice16BitStorageFeatures_temp(struct vn_cs_decoder *dec, VkPhysicalDevice16BitStorageFeatures *val)
1023 {
1024 VkStructureType stype;
1025 vn_decode_VkStructureType(dec, &stype);
1026 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES)
1027 vn_cs_decoder_set_fatal(dec);
1028
1029 val->sType = stype;
1030 val->pNext = vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext_temp(dec);
1031 vn_decode_VkPhysicalDevice16BitStorageFeatures_self_temp(dec, val);
1032 }
1033
1034 static inline void *
vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext_partial_temp(struct vn_cs_decoder * dec)1035 vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext_partial_temp(struct vn_cs_decoder *dec)
1036 {
1037 /* no known/supported struct */
1038 if (vn_decode_simple_pointer(dec))
1039 vn_cs_decoder_set_fatal(dec);
1040 return NULL;
1041 }
1042
1043 static inline void
vn_decode_VkPhysicalDevice16BitStorageFeatures_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDevice16BitStorageFeatures * val)1044 vn_decode_VkPhysicalDevice16BitStorageFeatures_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDevice16BitStorageFeatures *val)
1045 {
1046 /* skip val->{sType,pNext} */
1047 /* skip val->storageBuffer16BitAccess */
1048 /* skip val->uniformAndStorageBuffer16BitAccess */
1049 /* skip val->storagePushConstant16 */
1050 /* skip val->storageInputOutput16 */
1051 }
1052
1053 static inline void
vn_decode_VkPhysicalDevice16BitStorageFeatures_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDevice16BitStorageFeatures * val)1054 vn_decode_VkPhysicalDevice16BitStorageFeatures_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDevice16BitStorageFeatures *val)
1055 {
1056 VkStructureType stype;
1057 vn_decode_VkStructureType(dec, &stype);
1058 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES)
1059 vn_cs_decoder_set_fatal(dec);
1060
1061 val->sType = stype;
1062 val->pNext = vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext_partial_temp(dec);
1063 vn_decode_VkPhysicalDevice16BitStorageFeatures_self_partial_temp(dec, val);
1064 }
1065
1066 static inline void
vn_replace_VkPhysicalDevice16BitStorageFeatures_handle_self(VkPhysicalDevice16BitStorageFeatures * val)1067 vn_replace_VkPhysicalDevice16BitStorageFeatures_handle_self(VkPhysicalDevice16BitStorageFeatures *val)
1068 {
1069 /* skip val->sType */
1070 /* skip val->pNext */
1071 /* skip val->storageBuffer16BitAccess */
1072 /* skip val->uniformAndStorageBuffer16BitAccess */
1073 /* skip val->storagePushConstant16 */
1074 /* skip val->storageInputOutput16 */
1075 }
1076
1077 static inline void
vn_replace_VkPhysicalDevice16BitStorageFeatures_handle(VkPhysicalDevice16BitStorageFeatures * val)1078 vn_replace_VkPhysicalDevice16BitStorageFeatures_handle(VkPhysicalDevice16BitStorageFeatures *val)
1079 {
1080 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1081
1082 do {
1083 switch ((int32_t)pnext->sType) {
1084 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
1085 vn_replace_VkPhysicalDevice16BitStorageFeatures_handle_self((VkPhysicalDevice16BitStorageFeatures *)pnext);
1086 break;
1087 default:
1088 /* ignore unknown/unsupported struct */
1089 break;
1090 }
1091 pnext = pnext->pNext;
1092 } while (pnext);
1093 }
1094
1095 /* struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures chain */
1096
1097 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1098 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1099 {
1100 /* no known/supported struct */
1101 vn_encode_simple_pointer(enc, NULL);
1102 }
1103
1104 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1105 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1106 {
1107 /* skip val->{sType,pNext} */
1108 vn_encode_VkBool32(enc, &val->shaderSubgroupExtendedTypes);
1109 }
1110
1111 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1112 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1113 {
1114 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
1115 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES });
1116 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(enc, val->pNext);
1117 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, val);
1118 }
1119
1120 static inline void *
vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_temp(struct vn_cs_decoder * dec)1121 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_temp(struct vn_cs_decoder *dec)
1122 {
1123 /* no known/supported struct */
1124 if (vn_decode_simple_pointer(dec))
1125 vn_cs_decoder_set_fatal(dec);
1126 return NULL;
1127 }
1128
1129 static inline void
vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1130 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1131 {
1132 /* skip val->{sType,pNext} */
1133 vn_decode_VkBool32(dec, &val->shaderSubgroupExtendedTypes);
1134 }
1135
1136 static inline void
vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1137 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1138 {
1139 VkStructureType stype;
1140 vn_decode_VkStructureType(dec, &stype);
1141 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES)
1142 vn_cs_decoder_set_fatal(dec);
1143
1144 val->sType = stype;
1145 val->pNext = vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_temp(dec);
1146 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_temp(dec, val);
1147 }
1148
1149 static inline void *
vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial_temp(struct vn_cs_decoder * dec)1150 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial_temp(struct vn_cs_decoder *dec)
1151 {
1152 /* no known/supported struct */
1153 if (vn_decode_simple_pointer(dec))
1154 vn_cs_decoder_set_fatal(dec);
1155 return NULL;
1156 }
1157
1158 static inline void
vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1159 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1160 {
1161 /* skip val->{sType,pNext} */
1162 /* skip val->shaderSubgroupExtendedTypes */
1163 }
1164
1165 static inline void
vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1166 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1167 {
1168 VkStructureType stype;
1169 vn_decode_VkStructureType(dec, &stype);
1170 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES)
1171 vn_cs_decoder_set_fatal(dec);
1172
1173 val->sType = stype;
1174 val->pNext = vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial_temp(dec);
1175 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial_temp(dec, val);
1176 }
1177
1178 static inline void
vn_replace_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_handle_self(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1179 vn_replace_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_handle_self(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1180 {
1181 /* skip val->sType */
1182 /* skip val->pNext */
1183 /* skip val->shaderSubgroupExtendedTypes */
1184 }
1185
1186 static inline void
vn_replace_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_handle(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1187 vn_replace_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_handle(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1188 {
1189 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1190
1191 do {
1192 switch ((int32_t)pnext->sType) {
1193 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
1194 vn_replace_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_handle_self((VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
1195 break;
1196 default:
1197 /* ignore unknown/unsupported struct */
1198 break;
1199 }
1200 pnext = pnext->pNext;
1201 } while (pnext);
1202 }
1203
1204 /* struct VkPhysicalDeviceSamplerYcbcrConversionFeatures chain */
1205
1206 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1207 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1208 {
1209 /* no known/supported struct */
1210 vn_encode_simple_pointer(enc, NULL);
1211 }
1212
1213 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1214 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1215 {
1216 /* skip val->{sType,pNext} */
1217 vn_encode_VkBool32(enc, &val->samplerYcbcrConversion);
1218 }
1219
1220 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1221 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1222 {
1223 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
1224 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES });
1225 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(enc, val->pNext);
1226 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, val);
1227 }
1228
1229 static inline void *
vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_temp(struct vn_cs_decoder * dec)1230 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_temp(struct vn_cs_decoder *dec)
1231 {
1232 /* no known/supported struct */
1233 if (vn_decode_simple_pointer(dec))
1234 vn_cs_decoder_set_fatal(dec);
1235 return NULL;
1236 }
1237
1238 static inline void
vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1239 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1240 {
1241 /* skip val->{sType,pNext} */
1242 vn_decode_VkBool32(dec, &val->samplerYcbcrConversion);
1243 }
1244
1245 static inline void
vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1246 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1247 {
1248 VkStructureType stype;
1249 vn_decode_VkStructureType(dec, &stype);
1250 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES)
1251 vn_cs_decoder_set_fatal(dec);
1252
1253 val->sType = stype;
1254 val->pNext = vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_temp(dec);
1255 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_temp(dec, val);
1256 }
1257
1258 static inline void *
vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial_temp(struct vn_cs_decoder * dec)1259 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial_temp(struct vn_cs_decoder *dec)
1260 {
1261 /* no known/supported struct */
1262 if (vn_decode_simple_pointer(dec))
1263 vn_cs_decoder_set_fatal(dec);
1264 return NULL;
1265 }
1266
1267 static inline void
vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1268 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1269 {
1270 /* skip val->{sType,pNext} */
1271 /* skip val->samplerYcbcrConversion */
1272 }
1273
1274 static inline void
vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1275 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1276 {
1277 VkStructureType stype;
1278 vn_decode_VkStructureType(dec, &stype);
1279 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES)
1280 vn_cs_decoder_set_fatal(dec);
1281
1282 val->sType = stype;
1283 val->pNext = vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial_temp(dec);
1284 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial_temp(dec, val);
1285 }
1286
1287 static inline void
vn_replace_VkPhysicalDeviceSamplerYcbcrConversionFeatures_handle_self(VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1288 vn_replace_VkPhysicalDeviceSamplerYcbcrConversionFeatures_handle_self(VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1289 {
1290 /* skip val->sType */
1291 /* skip val->pNext */
1292 /* skip val->samplerYcbcrConversion */
1293 }
1294
1295 static inline void
vn_replace_VkPhysicalDeviceSamplerYcbcrConversionFeatures_handle(VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1296 vn_replace_VkPhysicalDeviceSamplerYcbcrConversionFeatures_handle(VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1297 {
1298 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1299
1300 do {
1301 switch ((int32_t)pnext->sType) {
1302 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
1303 vn_replace_VkPhysicalDeviceSamplerYcbcrConversionFeatures_handle_self((VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
1304 break;
1305 default:
1306 /* ignore unknown/unsupported struct */
1307 break;
1308 }
1309 pnext = pnext->pNext;
1310 } while (pnext);
1311 }
1312
1313 /* struct VkPhysicalDeviceProtectedMemoryFeatures chain */
1314
1315 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1316 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1317 {
1318 /* no known/supported struct */
1319 vn_encode_simple_pointer(enc, NULL);
1320 }
1321
1322 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryFeatures * val)1323 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
1324 {
1325 /* skip val->{sType,pNext} */
1326 vn_encode_VkBool32(enc, &val->protectedMemory);
1327 }
1328
1329 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryFeatures * val)1330 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
1331 {
1332 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
1333 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES });
1334 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(enc, val->pNext);
1335 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, val);
1336 }
1337
1338 static inline void *
vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_temp(struct vn_cs_decoder * dec)1339 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_temp(struct vn_cs_decoder *dec)
1340 {
1341 /* no known/supported struct */
1342 if (vn_decode_simple_pointer(dec))
1343 vn_cs_decoder_set_fatal(dec);
1344 return NULL;
1345 }
1346
1347 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryFeatures * val)1348 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryFeatures *val)
1349 {
1350 /* skip val->{sType,pNext} */
1351 vn_decode_VkBool32(dec, &val->protectedMemory);
1352 }
1353
1354 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryFeatures * val)1355 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryFeatures *val)
1356 {
1357 VkStructureType stype;
1358 vn_decode_VkStructureType(dec, &stype);
1359 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES)
1360 vn_cs_decoder_set_fatal(dec);
1361
1362 val->sType = stype;
1363 val->pNext = vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_temp(dec);
1364 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self_temp(dec, val);
1365 }
1366
1367 static inline void *
vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial_temp(struct vn_cs_decoder * dec)1368 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial_temp(struct vn_cs_decoder *dec)
1369 {
1370 /* no known/supported struct */
1371 if (vn_decode_simple_pointer(dec))
1372 vn_cs_decoder_set_fatal(dec);
1373 return NULL;
1374 }
1375
1376 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryFeatures * val)1377 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryFeatures *val)
1378 {
1379 /* skip val->{sType,pNext} */
1380 /* skip val->protectedMemory */
1381 }
1382
1383 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryFeatures * val)1384 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryFeatures *val)
1385 {
1386 VkStructureType stype;
1387 vn_decode_VkStructureType(dec, &stype);
1388 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES)
1389 vn_cs_decoder_set_fatal(dec);
1390
1391 val->sType = stype;
1392 val->pNext = vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial_temp(dec);
1393 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial_temp(dec, val);
1394 }
1395
1396 static inline void
vn_replace_VkPhysicalDeviceProtectedMemoryFeatures_handle_self(VkPhysicalDeviceProtectedMemoryFeatures * val)1397 vn_replace_VkPhysicalDeviceProtectedMemoryFeatures_handle_self(VkPhysicalDeviceProtectedMemoryFeatures *val)
1398 {
1399 /* skip val->sType */
1400 /* skip val->pNext */
1401 /* skip val->protectedMemory */
1402 }
1403
1404 static inline void
vn_replace_VkPhysicalDeviceProtectedMemoryFeatures_handle(VkPhysicalDeviceProtectedMemoryFeatures * val)1405 vn_replace_VkPhysicalDeviceProtectedMemoryFeatures_handle(VkPhysicalDeviceProtectedMemoryFeatures *val)
1406 {
1407 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1408
1409 do {
1410 switch ((int32_t)pnext->sType) {
1411 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
1412 vn_replace_VkPhysicalDeviceProtectedMemoryFeatures_handle_self((VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
1413 break;
1414 default:
1415 /* ignore unknown/unsupported struct */
1416 break;
1417 }
1418 pnext = pnext->pNext;
1419 } while (pnext);
1420 }
1421
1422 /* struct VkPhysicalDeviceShaderDrawParametersFeatures chain */
1423
1424 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1425 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1426 {
1427 /* no known/supported struct */
1428 vn_encode_simple_pointer(enc, NULL);
1429 }
1430
1431 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDrawParametersFeatures * val)1432 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
1433 {
1434 /* skip val->{sType,pNext} */
1435 vn_encode_VkBool32(enc, &val->shaderDrawParameters);
1436 }
1437
1438 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDrawParametersFeatures * val)1439 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
1440 {
1441 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
1442 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES });
1443 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(enc, val->pNext);
1444 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, val);
1445 }
1446
1447 static inline void *
vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_temp(struct vn_cs_decoder * dec)1448 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_temp(struct vn_cs_decoder *dec)
1449 {
1450 /* no known/supported struct */
1451 if (vn_decode_simple_pointer(dec))
1452 vn_cs_decoder_set_fatal(dec);
1453 return NULL;
1454 }
1455
1456 static inline void
vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderDrawParametersFeatures * val)1457 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDrawParametersFeatures *val)
1458 {
1459 /* skip val->{sType,pNext} */
1460 vn_decode_VkBool32(dec, &val->shaderDrawParameters);
1461 }
1462
1463 static inline void
vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderDrawParametersFeatures * val)1464 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDrawParametersFeatures *val)
1465 {
1466 VkStructureType stype;
1467 vn_decode_VkStructureType(dec, &stype);
1468 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES)
1469 vn_cs_decoder_set_fatal(dec);
1470
1471 val->sType = stype;
1472 val->pNext = vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_temp(dec);
1473 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self_temp(dec, val);
1474 }
1475
1476 static inline void *
vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial_temp(struct vn_cs_decoder * dec)1477 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial_temp(struct vn_cs_decoder *dec)
1478 {
1479 /* no known/supported struct */
1480 if (vn_decode_simple_pointer(dec))
1481 vn_cs_decoder_set_fatal(dec);
1482 return NULL;
1483 }
1484
1485 static inline void
vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderDrawParametersFeatures * val)1486 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDrawParametersFeatures *val)
1487 {
1488 /* skip val->{sType,pNext} */
1489 /* skip val->shaderDrawParameters */
1490 }
1491
1492 static inline void
vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderDrawParametersFeatures * val)1493 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDrawParametersFeatures *val)
1494 {
1495 VkStructureType stype;
1496 vn_decode_VkStructureType(dec, &stype);
1497 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES)
1498 vn_cs_decoder_set_fatal(dec);
1499
1500 val->sType = stype;
1501 val->pNext = vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial_temp(dec);
1502 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial_temp(dec, val);
1503 }
1504
1505 static inline void
vn_replace_VkPhysicalDeviceShaderDrawParametersFeatures_handle_self(VkPhysicalDeviceShaderDrawParametersFeatures * val)1506 vn_replace_VkPhysicalDeviceShaderDrawParametersFeatures_handle_self(VkPhysicalDeviceShaderDrawParametersFeatures *val)
1507 {
1508 /* skip val->sType */
1509 /* skip val->pNext */
1510 /* skip val->shaderDrawParameters */
1511 }
1512
1513 static inline void
vn_replace_VkPhysicalDeviceShaderDrawParametersFeatures_handle(VkPhysicalDeviceShaderDrawParametersFeatures * val)1514 vn_replace_VkPhysicalDeviceShaderDrawParametersFeatures_handle(VkPhysicalDeviceShaderDrawParametersFeatures *val)
1515 {
1516 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1517
1518 do {
1519 switch ((int32_t)pnext->sType) {
1520 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
1521 vn_replace_VkPhysicalDeviceShaderDrawParametersFeatures_handle_self((VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
1522 break;
1523 default:
1524 /* ignore unknown/unsupported struct */
1525 break;
1526 }
1527 pnext = pnext->pNext;
1528 } while (pnext);
1529 }
1530
1531 /* struct VkPhysicalDeviceShaderFloat16Int8Features chain */
1532
1533 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_encoder * enc,const void * val)1534 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_encoder *enc, const void *val)
1535 {
1536 /* no known/supported struct */
1537 vn_encode_simple_pointer(enc, NULL);
1538 }
1539
1540 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderFloat16Int8Features * val)1541 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
1542 {
1543 /* skip val->{sType,pNext} */
1544 vn_encode_VkBool32(enc, &val->shaderFloat16);
1545 vn_encode_VkBool32(enc, &val->shaderInt8);
1546 }
1547
1548 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderFloat16Int8Features * val)1549 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
1550 {
1551 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
1552 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES });
1553 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(enc, val->pNext);
1554 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, val);
1555 }
1556
1557 static inline void *
vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_temp(struct vn_cs_decoder * dec)1558 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_temp(struct vn_cs_decoder *dec)
1559 {
1560 /* no known/supported struct */
1561 if (vn_decode_simple_pointer(dec))
1562 vn_cs_decoder_set_fatal(dec);
1563 return NULL;
1564 }
1565
1566 static inline void
vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderFloat16Int8Features * val)1567 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderFloat16Int8Features *val)
1568 {
1569 /* skip val->{sType,pNext} */
1570 vn_decode_VkBool32(dec, &val->shaderFloat16);
1571 vn_decode_VkBool32(dec, &val->shaderInt8);
1572 }
1573
1574 static inline void
vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderFloat16Int8Features * val)1575 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderFloat16Int8Features *val)
1576 {
1577 VkStructureType stype;
1578 vn_decode_VkStructureType(dec, &stype);
1579 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES)
1580 vn_cs_decoder_set_fatal(dec);
1581
1582 val->sType = stype;
1583 val->pNext = vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_temp(dec);
1584 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self_temp(dec, val);
1585 }
1586
1587 static inline void *
vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial_temp(struct vn_cs_decoder * dec)1588 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial_temp(struct vn_cs_decoder *dec)
1589 {
1590 /* no known/supported struct */
1591 if (vn_decode_simple_pointer(dec))
1592 vn_cs_decoder_set_fatal(dec);
1593 return NULL;
1594 }
1595
1596 static inline void
vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderFloat16Int8Features * val)1597 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderFloat16Int8Features *val)
1598 {
1599 /* skip val->{sType,pNext} */
1600 /* skip val->shaderFloat16 */
1601 /* skip val->shaderInt8 */
1602 }
1603
1604 static inline void
vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderFloat16Int8Features * val)1605 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderFloat16Int8Features *val)
1606 {
1607 VkStructureType stype;
1608 vn_decode_VkStructureType(dec, &stype);
1609 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES)
1610 vn_cs_decoder_set_fatal(dec);
1611
1612 val->sType = stype;
1613 val->pNext = vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial_temp(dec);
1614 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial_temp(dec, val);
1615 }
1616
1617 static inline void
vn_replace_VkPhysicalDeviceShaderFloat16Int8Features_handle_self(VkPhysicalDeviceShaderFloat16Int8Features * val)1618 vn_replace_VkPhysicalDeviceShaderFloat16Int8Features_handle_self(VkPhysicalDeviceShaderFloat16Int8Features *val)
1619 {
1620 /* skip val->sType */
1621 /* skip val->pNext */
1622 /* skip val->shaderFloat16 */
1623 /* skip val->shaderInt8 */
1624 }
1625
1626 static inline void
vn_replace_VkPhysicalDeviceShaderFloat16Int8Features_handle(VkPhysicalDeviceShaderFloat16Int8Features * val)1627 vn_replace_VkPhysicalDeviceShaderFloat16Int8Features_handle(VkPhysicalDeviceShaderFloat16Int8Features *val)
1628 {
1629 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1630
1631 do {
1632 switch ((int32_t)pnext->sType) {
1633 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
1634 vn_replace_VkPhysicalDeviceShaderFloat16Int8Features_handle_self((VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
1635 break;
1636 default:
1637 /* ignore unknown/unsupported struct */
1638 break;
1639 }
1640 pnext = pnext->pNext;
1641 } while (pnext);
1642 }
1643
1644 /* struct VkPhysicalDeviceHostQueryResetFeatures chain */
1645
1646 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1647 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1648 {
1649 /* no known/supported struct */
1650 vn_encode_simple_pointer(enc, NULL);
1651 }
1652
1653 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceHostQueryResetFeatures * val)1654 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
1655 {
1656 /* skip val->{sType,pNext} */
1657 vn_encode_VkBool32(enc, &val->hostQueryReset);
1658 }
1659
1660 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceHostQueryResetFeatures * val)1661 vn_encode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
1662 {
1663 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
1664 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES });
1665 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(enc, val->pNext);
1666 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, val);
1667 }
1668
1669 static inline void *
vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext_temp(struct vn_cs_decoder * dec)1670 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext_temp(struct vn_cs_decoder *dec)
1671 {
1672 /* no known/supported struct */
1673 if (vn_decode_simple_pointer(dec))
1674 vn_cs_decoder_set_fatal(dec);
1675 return NULL;
1676 }
1677
1678 static inline void
vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceHostQueryResetFeatures * val)1679 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceHostQueryResetFeatures *val)
1680 {
1681 /* skip val->{sType,pNext} */
1682 vn_decode_VkBool32(dec, &val->hostQueryReset);
1683 }
1684
1685 static inline void
vn_decode_VkPhysicalDeviceHostQueryResetFeatures_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceHostQueryResetFeatures * val)1686 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceHostQueryResetFeatures *val)
1687 {
1688 VkStructureType stype;
1689 vn_decode_VkStructureType(dec, &stype);
1690 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES)
1691 vn_cs_decoder_set_fatal(dec);
1692
1693 val->sType = stype;
1694 val->pNext = vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext_temp(dec);
1695 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self_temp(dec, val);
1696 }
1697
1698 static inline void *
vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial_temp(struct vn_cs_decoder * dec)1699 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial_temp(struct vn_cs_decoder *dec)
1700 {
1701 /* no known/supported struct */
1702 if (vn_decode_simple_pointer(dec))
1703 vn_cs_decoder_set_fatal(dec);
1704 return NULL;
1705 }
1706
1707 static inline void
vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceHostQueryResetFeatures * val)1708 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceHostQueryResetFeatures *val)
1709 {
1710 /* skip val->{sType,pNext} */
1711 /* skip val->hostQueryReset */
1712 }
1713
1714 static inline void
vn_decode_VkPhysicalDeviceHostQueryResetFeatures_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceHostQueryResetFeatures * val)1715 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceHostQueryResetFeatures *val)
1716 {
1717 VkStructureType stype;
1718 vn_decode_VkStructureType(dec, &stype);
1719 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES)
1720 vn_cs_decoder_set_fatal(dec);
1721
1722 val->sType = stype;
1723 val->pNext = vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial_temp(dec);
1724 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self_partial_temp(dec, val);
1725 }
1726
1727 static inline void
vn_replace_VkPhysicalDeviceHostQueryResetFeatures_handle_self(VkPhysicalDeviceHostQueryResetFeatures * val)1728 vn_replace_VkPhysicalDeviceHostQueryResetFeatures_handle_self(VkPhysicalDeviceHostQueryResetFeatures *val)
1729 {
1730 /* skip val->sType */
1731 /* skip val->pNext */
1732 /* skip val->hostQueryReset */
1733 }
1734
1735 static inline void
vn_replace_VkPhysicalDeviceHostQueryResetFeatures_handle(VkPhysicalDeviceHostQueryResetFeatures * val)1736 vn_replace_VkPhysicalDeviceHostQueryResetFeatures_handle(VkPhysicalDeviceHostQueryResetFeatures *val)
1737 {
1738 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1739
1740 do {
1741 switch ((int32_t)pnext->sType) {
1742 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
1743 vn_replace_VkPhysicalDeviceHostQueryResetFeatures_handle_self((VkPhysicalDeviceHostQueryResetFeatures *)pnext);
1744 break;
1745 default:
1746 /* ignore unknown/unsupported struct */
1747 break;
1748 }
1749 pnext = pnext->pNext;
1750 } while (pnext);
1751 }
1752
1753 /* struct VkPhysicalDeviceDescriptorIndexingFeatures chain */
1754
1755 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1756 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1757 {
1758 /* no known/supported struct */
1759 vn_encode_simple_pointer(enc, NULL);
1760 }
1761
1762 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingFeatures * val)1763 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
1764 {
1765 /* skip val->{sType,pNext} */
1766 vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayDynamicIndexing);
1767 vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayDynamicIndexing);
1768 vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayDynamicIndexing);
1769 vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayNonUniformIndexing);
1770 vn_encode_VkBool32(enc, &val->shaderSampledImageArrayNonUniformIndexing);
1771 vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayNonUniformIndexing);
1772 vn_encode_VkBool32(enc, &val->shaderStorageImageArrayNonUniformIndexing);
1773 vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayNonUniformIndexing);
1774 vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
1775 vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
1776 vn_encode_VkBool32(enc, &val->descriptorBindingUniformBufferUpdateAfterBind);
1777 vn_encode_VkBool32(enc, &val->descriptorBindingSampledImageUpdateAfterBind);
1778 vn_encode_VkBool32(enc, &val->descriptorBindingStorageImageUpdateAfterBind);
1779 vn_encode_VkBool32(enc, &val->descriptorBindingStorageBufferUpdateAfterBind);
1780 vn_encode_VkBool32(enc, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
1781 vn_encode_VkBool32(enc, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
1782 vn_encode_VkBool32(enc, &val->descriptorBindingUpdateUnusedWhilePending);
1783 vn_encode_VkBool32(enc, &val->descriptorBindingPartiallyBound);
1784 vn_encode_VkBool32(enc, &val->descriptorBindingVariableDescriptorCount);
1785 vn_encode_VkBool32(enc, &val->runtimeDescriptorArray);
1786 }
1787
1788 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingFeatures * val)1789 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
1790 {
1791 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
1792 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES });
1793 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(enc, val->pNext);
1794 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, val);
1795 }
1796
1797 static inline void *
vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_temp(struct vn_cs_decoder * dec)1798 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_temp(struct vn_cs_decoder *dec)
1799 {
1800 /* no known/supported struct */
1801 if (vn_decode_simple_pointer(dec))
1802 vn_cs_decoder_set_fatal(dec);
1803 return NULL;
1804 }
1805
1806 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingFeatures * val)1807 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingFeatures *val)
1808 {
1809 /* skip val->{sType,pNext} */
1810 vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayDynamicIndexing);
1811 vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayDynamicIndexing);
1812 vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayDynamicIndexing);
1813 vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexing);
1814 vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexing);
1815 vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexing);
1816 vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexing);
1817 vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexing);
1818 vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
1819 vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
1820 vn_decode_VkBool32(dec, &val->descriptorBindingUniformBufferUpdateAfterBind);
1821 vn_decode_VkBool32(dec, &val->descriptorBindingSampledImageUpdateAfterBind);
1822 vn_decode_VkBool32(dec, &val->descriptorBindingStorageImageUpdateAfterBind);
1823 vn_decode_VkBool32(dec, &val->descriptorBindingStorageBufferUpdateAfterBind);
1824 vn_decode_VkBool32(dec, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
1825 vn_decode_VkBool32(dec, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
1826 vn_decode_VkBool32(dec, &val->descriptorBindingUpdateUnusedWhilePending);
1827 vn_decode_VkBool32(dec, &val->descriptorBindingPartiallyBound);
1828 vn_decode_VkBool32(dec, &val->descriptorBindingVariableDescriptorCount);
1829 vn_decode_VkBool32(dec, &val->runtimeDescriptorArray);
1830 }
1831
1832 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingFeatures * val)1833 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingFeatures *val)
1834 {
1835 VkStructureType stype;
1836 vn_decode_VkStructureType(dec, &stype);
1837 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES)
1838 vn_cs_decoder_set_fatal(dec);
1839
1840 val->sType = stype;
1841 val->pNext = vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_temp(dec);
1842 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self_temp(dec, val);
1843 }
1844
1845 static inline void *
vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial_temp(struct vn_cs_decoder * dec)1846 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial_temp(struct vn_cs_decoder *dec)
1847 {
1848 /* no known/supported struct */
1849 if (vn_decode_simple_pointer(dec))
1850 vn_cs_decoder_set_fatal(dec);
1851 return NULL;
1852 }
1853
1854 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingFeatures * val)1855 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingFeatures *val)
1856 {
1857 /* skip val->{sType,pNext} */
1858 /* skip val->shaderInputAttachmentArrayDynamicIndexing */
1859 /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
1860 /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
1861 /* skip val->shaderUniformBufferArrayNonUniformIndexing */
1862 /* skip val->shaderSampledImageArrayNonUniformIndexing */
1863 /* skip val->shaderStorageBufferArrayNonUniformIndexing */
1864 /* skip val->shaderStorageImageArrayNonUniformIndexing */
1865 /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
1866 /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
1867 /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
1868 /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
1869 /* skip val->descriptorBindingSampledImageUpdateAfterBind */
1870 /* skip val->descriptorBindingStorageImageUpdateAfterBind */
1871 /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
1872 /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
1873 /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
1874 /* skip val->descriptorBindingUpdateUnusedWhilePending */
1875 /* skip val->descriptorBindingPartiallyBound */
1876 /* skip val->descriptorBindingVariableDescriptorCount */
1877 /* skip val->runtimeDescriptorArray */
1878 }
1879
1880 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingFeatures * val)1881 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingFeatures *val)
1882 {
1883 VkStructureType stype;
1884 vn_decode_VkStructureType(dec, &stype);
1885 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES)
1886 vn_cs_decoder_set_fatal(dec);
1887
1888 val->sType = stype;
1889 val->pNext = vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial_temp(dec);
1890 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial_temp(dec, val);
1891 }
1892
1893 static inline void
vn_replace_VkPhysicalDeviceDescriptorIndexingFeatures_handle_self(VkPhysicalDeviceDescriptorIndexingFeatures * val)1894 vn_replace_VkPhysicalDeviceDescriptorIndexingFeatures_handle_self(VkPhysicalDeviceDescriptorIndexingFeatures *val)
1895 {
1896 /* skip val->sType */
1897 /* skip val->pNext */
1898 /* skip val->shaderInputAttachmentArrayDynamicIndexing */
1899 /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
1900 /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
1901 /* skip val->shaderUniformBufferArrayNonUniformIndexing */
1902 /* skip val->shaderSampledImageArrayNonUniformIndexing */
1903 /* skip val->shaderStorageBufferArrayNonUniformIndexing */
1904 /* skip val->shaderStorageImageArrayNonUniformIndexing */
1905 /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
1906 /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
1907 /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
1908 /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
1909 /* skip val->descriptorBindingSampledImageUpdateAfterBind */
1910 /* skip val->descriptorBindingStorageImageUpdateAfterBind */
1911 /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
1912 /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
1913 /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
1914 /* skip val->descriptorBindingUpdateUnusedWhilePending */
1915 /* skip val->descriptorBindingPartiallyBound */
1916 /* skip val->descriptorBindingVariableDescriptorCount */
1917 /* skip val->runtimeDescriptorArray */
1918 }
1919
1920 static inline void
vn_replace_VkPhysicalDeviceDescriptorIndexingFeatures_handle(VkPhysicalDeviceDescriptorIndexingFeatures * val)1921 vn_replace_VkPhysicalDeviceDescriptorIndexingFeatures_handle(VkPhysicalDeviceDescriptorIndexingFeatures *val)
1922 {
1923 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1924
1925 do {
1926 switch ((int32_t)pnext->sType) {
1927 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
1928 vn_replace_VkPhysicalDeviceDescriptorIndexingFeatures_handle_self((VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
1929 break;
1930 default:
1931 /* ignore unknown/unsupported struct */
1932 break;
1933 }
1934 pnext = pnext->pNext;
1935 } while (pnext);
1936 }
1937
1938 /* struct VkPhysicalDeviceTimelineSemaphoreFeatures chain */
1939
1940 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1941 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1942 {
1943 /* no known/supported struct */
1944 vn_encode_simple_pointer(enc, NULL);
1945 }
1946
1947 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreFeatures * val)1948 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
1949 {
1950 /* skip val->{sType,pNext} */
1951 vn_encode_VkBool32(enc, &val->timelineSemaphore);
1952 }
1953
1954 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreFeatures * val)1955 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
1956 {
1957 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
1958 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES });
1959 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(enc, val->pNext);
1960 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, val);
1961 }
1962
1963 static inline void *
vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_temp(struct vn_cs_decoder * dec)1964 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_temp(struct vn_cs_decoder *dec)
1965 {
1966 /* no known/supported struct */
1967 if (vn_decode_simple_pointer(dec))
1968 vn_cs_decoder_set_fatal(dec);
1969 return NULL;
1970 }
1971
1972 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreFeatures * val)1973 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreFeatures *val)
1974 {
1975 /* skip val->{sType,pNext} */
1976 vn_decode_VkBool32(dec, &val->timelineSemaphore);
1977 }
1978
1979 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreFeatures * val)1980 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreFeatures *val)
1981 {
1982 VkStructureType stype;
1983 vn_decode_VkStructureType(dec, &stype);
1984 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES)
1985 vn_cs_decoder_set_fatal(dec);
1986
1987 val->sType = stype;
1988 val->pNext = vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_temp(dec);
1989 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_temp(dec, val);
1990 }
1991
1992 static inline void *
vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial_temp(struct vn_cs_decoder * dec)1993 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial_temp(struct vn_cs_decoder *dec)
1994 {
1995 /* no known/supported struct */
1996 if (vn_decode_simple_pointer(dec))
1997 vn_cs_decoder_set_fatal(dec);
1998 return NULL;
1999 }
2000
2001 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreFeatures * val)2002 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2003 {
2004 /* skip val->{sType,pNext} */
2005 /* skip val->timelineSemaphore */
2006 }
2007
2008 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreFeatures * val)2009 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2010 {
2011 VkStructureType stype;
2012 vn_decode_VkStructureType(dec, &stype);
2013 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES)
2014 vn_cs_decoder_set_fatal(dec);
2015
2016 val->sType = stype;
2017 val->pNext = vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial_temp(dec);
2018 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial_temp(dec, val);
2019 }
2020
2021 static inline void
vn_replace_VkPhysicalDeviceTimelineSemaphoreFeatures_handle_self(VkPhysicalDeviceTimelineSemaphoreFeatures * val)2022 vn_replace_VkPhysicalDeviceTimelineSemaphoreFeatures_handle_self(VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2023 {
2024 /* skip val->sType */
2025 /* skip val->pNext */
2026 /* skip val->timelineSemaphore */
2027 }
2028
2029 static inline void
vn_replace_VkPhysicalDeviceTimelineSemaphoreFeatures_handle(VkPhysicalDeviceTimelineSemaphoreFeatures * val)2030 vn_replace_VkPhysicalDeviceTimelineSemaphoreFeatures_handle(VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2031 {
2032 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
2033
2034 do {
2035 switch ((int32_t)pnext->sType) {
2036 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
2037 vn_replace_VkPhysicalDeviceTimelineSemaphoreFeatures_handle_self((VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
2038 break;
2039 default:
2040 /* ignore unknown/unsupported struct */
2041 break;
2042 }
2043 pnext = pnext->pNext;
2044 } while (pnext);
2045 }
2046
2047 /* struct VkPhysicalDevice8BitStorageFeatures chain */
2048
2049 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2050 vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2051 {
2052 /* no known/supported struct */
2053 vn_encode_simple_pointer(enc, NULL);
2054 }
2055
2056 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDevice8BitStorageFeatures * val)2057 vn_encode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
2058 {
2059 /* skip val->{sType,pNext} */
2060 vn_encode_VkBool32(enc, &val->storageBuffer8BitAccess);
2061 vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer8BitAccess);
2062 vn_encode_VkBool32(enc, &val->storagePushConstant8);
2063 }
2064
2065 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_encoder * enc,const VkPhysicalDevice8BitStorageFeatures * val)2066 vn_encode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
2067 {
2068 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
2069 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES });
2070 vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(enc, val->pNext);
2071 vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, val);
2072 }
2073
2074 static inline void *
vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext_temp(struct vn_cs_decoder * dec)2075 vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext_temp(struct vn_cs_decoder *dec)
2076 {
2077 /* no known/supported struct */
2078 if (vn_decode_simple_pointer(dec))
2079 vn_cs_decoder_set_fatal(dec);
2080 return NULL;
2081 }
2082
2083 static inline void
vn_decode_VkPhysicalDevice8BitStorageFeatures_self_temp(struct vn_cs_decoder * dec,VkPhysicalDevice8BitStorageFeatures * val)2084 vn_decode_VkPhysicalDevice8BitStorageFeatures_self_temp(struct vn_cs_decoder *dec, VkPhysicalDevice8BitStorageFeatures *val)
2085 {
2086 /* skip val->{sType,pNext} */
2087 vn_decode_VkBool32(dec, &val->storageBuffer8BitAccess);
2088 vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer8BitAccess);
2089 vn_decode_VkBool32(dec, &val->storagePushConstant8);
2090 }
2091
2092 static inline void
vn_decode_VkPhysicalDevice8BitStorageFeatures_temp(struct vn_cs_decoder * dec,VkPhysicalDevice8BitStorageFeatures * val)2093 vn_decode_VkPhysicalDevice8BitStorageFeatures_temp(struct vn_cs_decoder *dec, VkPhysicalDevice8BitStorageFeatures *val)
2094 {
2095 VkStructureType stype;
2096 vn_decode_VkStructureType(dec, &stype);
2097 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES)
2098 vn_cs_decoder_set_fatal(dec);
2099
2100 val->sType = stype;
2101 val->pNext = vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext_temp(dec);
2102 vn_decode_VkPhysicalDevice8BitStorageFeatures_self_temp(dec, val);
2103 }
2104
2105 static inline void *
vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext_partial_temp(struct vn_cs_decoder * dec)2106 vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext_partial_temp(struct vn_cs_decoder *dec)
2107 {
2108 /* no known/supported struct */
2109 if (vn_decode_simple_pointer(dec))
2110 vn_cs_decoder_set_fatal(dec);
2111 return NULL;
2112 }
2113
2114 static inline void
vn_decode_VkPhysicalDevice8BitStorageFeatures_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDevice8BitStorageFeatures * val)2115 vn_decode_VkPhysicalDevice8BitStorageFeatures_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDevice8BitStorageFeatures *val)
2116 {
2117 /* skip val->{sType,pNext} */
2118 /* skip val->storageBuffer8BitAccess */
2119 /* skip val->uniformAndStorageBuffer8BitAccess */
2120 /* skip val->storagePushConstant8 */
2121 }
2122
2123 static inline void
vn_decode_VkPhysicalDevice8BitStorageFeatures_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDevice8BitStorageFeatures * val)2124 vn_decode_VkPhysicalDevice8BitStorageFeatures_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDevice8BitStorageFeatures *val)
2125 {
2126 VkStructureType stype;
2127 vn_decode_VkStructureType(dec, &stype);
2128 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES)
2129 vn_cs_decoder_set_fatal(dec);
2130
2131 val->sType = stype;
2132 val->pNext = vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext_partial_temp(dec);
2133 vn_decode_VkPhysicalDevice8BitStorageFeatures_self_partial_temp(dec, val);
2134 }
2135
2136 static inline void
vn_replace_VkPhysicalDevice8BitStorageFeatures_handle_self(VkPhysicalDevice8BitStorageFeatures * val)2137 vn_replace_VkPhysicalDevice8BitStorageFeatures_handle_self(VkPhysicalDevice8BitStorageFeatures *val)
2138 {
2139 /* skip val->sType */
2140 /* skip val->pNext */
2141 /* skip val->storageBuffer8BitAccess */
2142 /* skip val->uniformAndStorageBuffer8BitAccess */
2143 /* skip val->storagePushConstant8 */
2144 }
2145
2146 static inline void
vn_replace_VkPhysicalDevice8BitStorageFeatures_handle(VkPhysicalDevice8BitStorageFeatures * val)2147 vn_replace_VkPhysicalDevice8BitStorageFeatures_handle(VkPhysicalDevice8BitStorageFeatures *val)
2148 {
2149 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
2150
2151 do {
2152 switch ((int32_t)pnext->sType) {
2153 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
2154 vn_replace_VkPhysicalDevice8BitStorageFeatures_handle_self((VkPhysicalDevice8BitStorageFeatures *)pnext);
2155 break;
2156 default:
2157 /* ignore unknown/unsupported struct */
2158 break;
2159 }
2160 pnext = pnext->pNext;
2161 } while (pnext);
2162 }
2163
2164 /* struct VkPhysicalDeviceVulkanMemoryModelFeatures chain */
2165
2166 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2167 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2168 {
2169 /* no known/supported struct */
2170 vn_encode_simple_pointer(enc, NULL);
2171 }
2172
2173 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkanMemoryModelFeatures * val)2174 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
2175 {
2176 /* skip val->{sType,pNext} */
2177 vn_encode_VkBool32(enc, &val->vulkanMemoryModel);
2178 vn_encode_VkBool32(enc, &val->vulkanMemoryModelDeviceScope);
2179 vn_encode_VkBool32(enc, &val->vulkanMemoryModelAvailabilityVisibilityChains);
2180 }
2181
2182 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkanMemoryModelFeatures * val)2183 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
2184 {
2185 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
2186 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES });
2187 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(enc, val->pNext);
2188 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, val);
2189 }
2190
2191 static inline void *
vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_temp(struct vn_cs_decoder * dec)2192 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_temp(struct vn_cs_decoder *dec)
2193 {
2194 /* no known/supported struct */
2195 if (vn_decode_simple_pointer(dec))
2196 vn_cs_decoder_set_fatal(dec);
2197 return NULL;
2198 }
2199
2200 static inline void
vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkanMemoryModelFeatures * val)2201 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkanMemoryModelFeatures *val)
2202 {
2203 /* skip val->{sType,pNext} */
2204 vn_decode_VkBool32(dec, &val->vulkanMemoryModel);
2205 vn_decode_VkBool32(dec, &val->vulkanMemoryModelDeviceScope);
2206 vn_decode_VkBool32(dec, &val->vulkanMemoryModelAvailabilityVisibilityChains);
2207 }
2208
2209 static inline void
vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkanMemoryModelFeatures * val)2210 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkanMemoryModelFeatures *val)
2211 {
2212 VkStructureType stype;
2213 vn_decode_VkStructureType(dec, &stype);
2214 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES)
2215 vn_cs_decoder_set_fatal(dec);
2216
2217 val->sType = stype;
2218 val->pNext = vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_temp(dec);
2219 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_temp(dec, val);
2220 }
2221
2222 static inline void *
vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial_temp(struct vn_cs_decoder * dec)2223 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial_temp(struct vn_cs_decoder *dec)
2224 {
2225 /* no known/supported struct */
2226 if (vn_decode_simple_pointer(dec))
2227 vn_cs_decoder_set_fatal(dec);
2228 return NULL;
2229 }
2230
2231 static inline void
vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkanMemoryModelFeatures * val)2232 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkanMemoryModelFeatures *val)
2233 {
2234 /* skip val->{sType,pNext} */
2235 /* skip val->vulkanMemoryModel */
2236 /* skip val->vulkanMemoryModelDeviceScope */
2237 /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
2238 }
2239
2240 static inline void
vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkanMemoryModelFeatures * val)2241 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkanMemoryModelFeatures *val)
2242 {
2243 VkStructureType stype;
2244 vn_decode_VkStructureType(dec, &stype);
2245 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES)
2246 vn_cs_decoder_set_fatal(dec);
2247
2248 val->sType = stype;
2249 val->pNext = vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial_temp(dec);
2250 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial_temp(dec, val);
2251 }
2252
2253 static inline void
vn_replace_VkPhysicalDeviceVulkanMemoryModelFeatures_handle_self(VkPhysicalDeviceVulkanMemoryModelFeatures * val)2254 vn_replace_VkPhysicalDeviceVulkanMemoryModelFeatures_handle_self(VkPhysicalDeviceVulkanMemoryModelFeatures *val)
2255 {
2256 /* skip val->sType */
2257 /* skip val->pNext */
2258 /* skip val->vulkanMemoryModel */
2259 /* skip val->vulkanMemoryModelDeviceScope */
2260 /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
2261 }
2262
2263 static inline void
vn_replace_VkPhysicalDeviceVulkanMemoryModelFeatures_handle(VkPhysicalDeviceVulkanMemoryModelFeatures * val)2264 vn_replace_VkPhysicalDeviceVulkanMemoryModelFeatures_handle(VkPhysicalDeviceVulkanMemoryModelFeatures *val)
2265 {
2266 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
2267
2268 do {
2269 switch ((int32_t)pnext->sType) {
2270 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
2271 vn_replace_VkPhysicalDeviceVulkanMemoryModelFeatures_handle_self((VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
2272 break;
2273 default:
2274 /* ignore unknown/unsupported struct */
2275 break;
2276 }
2277 pnext = pnext->pNext;
2278 } while (pnext);
2279 }
2280
2281 /* struct VkPhysicalDeviceShaderAtomicInt64Features chain */
2282
2283 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_encoder * enc,const void * val)2284 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_encoder *enc, const void *val)
2285 {
2286 /* no known/supported struct */
2287 vn_encode_simple_pointer(enc, NULL);
2288 }
2289
2290 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderAtomicInt64Features * val)2291 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
2292 {
2293 /* skip val->{sType,pNext} */
2294 vn_encode_VkBool32(enc, &val->shaderBufferInt64Atomics);
2295 vn_encode_VkBool32(enc, &val->shaderSharedInt64Atomics);
2296 }
2297
2298 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderAtomicInt64Features * val)2299 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
2300 {
2301 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
2302 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES });
2303 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(enc, val->pNext);
2304 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, val);
2305 }
2306
2307 static inline void *
vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_temp(struct vn_cs_decoder * dec)2308 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_temp(struct vn_cs_decoder *dec)
2309 {
2310 /* no known/supported struct */
2311 if (vn_decode_simple_pointer(dec))
2312 vn_cs_decoder_set_fatal(dec);
2313 return NULL;
2314 }
2315
2316 static inline void
vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderAtomicInt64Features * val)2317 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderAtomicInt64Features *val)
2318 {
2319 /* skip val->{sType,pNext} */
2320 vn_decode_VkBool32(dec, &val->shaderBufferInt64Atomics);
2321 vn_decode_VkBool32(dec, &val->shaderSharedInt64Atomics);
2322 }
2323
2324 static inline void
vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderAtomicInt64Features * val)2325 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderAtomicInt64Features *val)
2326 {
2327 VkStructureType stype;
2328 vn_decode_VkStructureType(dec, &stype);
2329 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES)
2330 vn_cs_decoder_set_fatal(dec);
2331
2332 val->sType = stype;
2333 val->pNext = vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_temp(dec);
2334 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self_temp(dec, val);
2335 }
2336
2337 static inline void *
vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial_temp(struct vn_cs_decoder * dec)2338 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial_temp(struct vn_cs_decoder *dec)
2339 {
2340 /* no known/supported struct */
2341 if (vn_decode_simple_pointer(dec))
2342 vn_cs_decoder_set_fatal(dec);
2343 return NULL;
2344 }
2345
2346 static inline void
vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderAtomicInt64Features * val)2347 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderAtomicInt64Features *val)
2348 {
2349 /* skip val->{sType,pNext} */
2350 /* skip val->shaderBufferInt64Atomics */
2351 /* skip val->shaderSharedInt64Atomics */
2352 }
2353
2354 static inline void
vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderAtomicInt64Features * val)2355 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderAtomicInt64Features *val)
2356 {
2357 VkStructureType stype;
2358 vn_decode_VkStructureType(dec, &stype);
2359 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES)
2360 vn_cs_decoder_set_fatal(dec);
2361
2362 val->sType = stype;
2363 val->pNext = vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial_temp(dec);
2364 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial_temp(dec, val);
2365 }
2366
2367 static inline void
vn_replace_VkPhysicalDeviceShaderAtomicInt64Features_handle_self(VkPhysicalDeviceShaderAtomicInt64Features * val)2368 vn_replace_VkPhysicalDeviceShaderAtomicInt64Features_handle_self(VkPhysicalDeviceShaderAtomicInt64Features *val)
2369 {
2370 /* skip val->sType */
2371 /* skip val->pNext */
2372 /* skip val->shaderBufferInt64Atomics */
2373 /* skip val->shaderSharedInt64Atomics */
2374 }
2375
2376 static inline void
vn_replace_VkPhysicalDeviceShaderAtomicInt64Features_handle(VkPhysicalDeviceShaderAtomicInt64Features * val)2377 vn_replace_VkPhysicalDeviceShaderAtomicInt64Features_handle(VkPhysicalDeviceShaderAtomicInt64Features *val)
2378 {
2379 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
2380
2381 do {
2382 switch ((int32_t)pnext->sType) {
2383 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
2384 vn_replace_VkPhysicalDeviceShaderAtomicInt64Features_handle_self((VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
2385 break;
2386 default:
2387 /* ignore unknown/unsupported struct */
2388 break;
2389 }
2390 pnext = pnext->pNext;
2391 } while (pnext);
2392 }
2393
2394 /* struct VkPhysicalDeviceTransformFeedbackFeaturesEXT chain */
2395
2396 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)2397 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
2398 {
2399 /* no known/supported struct */
2400 vn_encode_simple_pointer(enc, NULL);
2401 }
2402
2403 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)2404 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
2405 {
2406 /* skip val->{sType,pNext} */
2407 vn_encode_VkBool32(enc, &val->transformFeedback);
2408 vn_encode_VkBool32(enc, &val->geometryStreams);
2409 }
2410
2411 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)2412 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
2413 {
2414 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
2415 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT });
2416 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(enc, val->pNext);
2417 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, val);
2418 }
2419
2420 static inline void *
vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_temp(struct vn_cs_decoder * dec)2421 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_temp(struct vn_cs_decoder *dec)
2422 {
2423 /* no known/supported struct */
2424 if (vn_decode_simple_pointer(dec))
2425 vn_cs_decoder_set_fatal(dec);
2426 return NULL;
2427 }
2428
2429 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)2430 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
2431 {
2432 /* skip val->{sType,pNext} */
2433 vn_decode_VkBool32(dec, &val->transformFeedback);
2434 vn_decode_VkBool32(dec, &val->geometryStreams);
2435 }
2436
2437 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)2438 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
2439 {
2440 VkStructureType stype;
2441 vn_decode_VkStructureType(dec, &stype);
2442 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT)
2443 vn_cs_decoder_set_fatal(dec);
2444
2445 val->sType = stype;
2446 val->pNext = vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_temp(dec);
2447 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_temp(dec, val);
2448 }
2449
2450 static inline void *
vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial_temp(struct vn_cs_decoder * dec)2451 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial_temp(struct vn_cs_decoder *dec)
2452 {
2453 /* no known/supported struct */
2454 if (vn_decode_simple_pointer(dec))
2455 vn_cs_decoder_set_fatal(dec);
2456 return NULL;
2457 }
2458
2459 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)2460 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
2461 {
2462 /* skip val->{sType,pNext} */
2463 /* skip val->transformFeedback */
2464 /* skip val->geometryStreams */
2465 }
2466
2467 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)2468 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
2469 {
2470 VkStructureType stype;
2471 vn_decode_VkStructureType(dec, &stype);
2472 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT)
2473 vn_cs_decoder_set_fatal(dec);
2474
2475 val->sType = stype;
2476 val->pNext = vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial_temp(dec);
2477 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial_temp(dec, val);
2478 }
2479
2480 static inline void
vn_replace_VkPhysicalDeviceTransformFeedbackFeaturesEXT_handle_self(VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)2481 vn_replace_VkPhysicalDeviceTransformFeedbackFeaturesEXT_handle_self(VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
2482 {
2483 /* skip val->sType */
2484 /* skip val->pNext */
2485 /* skip val->transformFeedback */
2486 /* skip val->geometryStreams */
2487 }
2488
2489 static inline void
vn_replace_VkPhysicalDeviceTransformFeedbackFeaturesEXT_handle(VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)2490 vn_replace_VkPhysicalDeviceTransformFeedbackFeaturesEXT_handle(VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
2491 {
2492 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
2493
2494 do {
2495 switch ((int32_t)pnext->sType) {
2496 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
2497 vn_replace_VkPhysicalDeviceTransformFeedbackFeaturesEXT_handle_self((VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
2498 break;
2499 default:
2500 /* ignore unknown/unsupported struct */
2501 break;
2502 }
2503 pnext = pnext->pNext;
2504 } while (pnext);
2505 }
2506
2507 /* struct VkPhysicalDeviceScalarBlockLayoutFeatures chain */
2508
2509 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2510 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2511 {
2512 /* no known/supported struct */
2513 vn_encode_simple_pointer(enc, NULL);
2514 }
2515
2516 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceScalarBlockLayoutFeatures * val)2517 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
2518 {
2519 /* skip val->{sType,pNext} */
2520 vn_encode_VkBool32(enc, &val->scalarBlockLayout);
2521 }
2522
2523 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceScalarBlockLayoutFeatures * val)2524 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
2525 {
2526 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
2527 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES });
2528 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(enc, val->pNext);
2529 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, val);
2530 }
2531
2532 static inline void *
vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_temp(struct vn_cs_decoder * dec)2533 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_temp(struct vn_cs_decoder *dec)
2534 {
2535 /* no known/supported struct */
2536 if (vn_decode_simple_pointer(dec))
2537 vn_cs_decoder_set_fatal(dec);
2538 return NULL;
2539 }
2540
2541 static inline void
vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceScalarBlockLayoutFeatures * val)2542 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceScalarBlockLayoutFeatures *val)
2543 {
2544 /* skip val->{sType,pNext} */
2545 vn_decode_VkBool32(dec, &val->scalarBlockLayout);
2546 }
2547
2548 static inline void
vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceScalarBlockLayoutFeatures * val)2549 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceScalarBlockLayoutFeatures *val)
2550 {
2551 VkStructureType stype;
2552 vn_decode_VkStructureType(dec, &stype);
2553 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES)
2554 vn_cs_decoder_set_fatal(dec);
2555
2556 val->sType = stype;
2557 val->pNext = vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_temp(dec);
2558 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_temp(dec, val);
2559 }
2560
2561 static inline void *
vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial_temp(struct vn_cs_decoder * dec)2562 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial_temp(struct vn_cs_decoder *dec)
2563 {
2564 /* no known/supported struct */
2565 if (vn_decode_simple_pointer(dec))
2566 vn_cs_decoder_set_fatal(dec);
2567 return NULL;
2568 }
2569
2570 static inline void
vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceScalarBlockLayoutFeatures * val)2571 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceScalarBlockLayoutFeatures *val)
2572 {
2573 /* skip val->{sType,pNext} */
2574 /* skip val->scalarBlockLayout */
2575 }
2576
2577 static inline void
vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceScalarBlockLayoutFeatures * val)2578 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceScalarBlockLayoutFeatures *val)
2579 {
2580 VkStructureType stype;
2581 vn_decode_VkStructureType(dec, &stype);
2582 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES)
2583 vn_cs_decoder_set_fatal(dec);
2584
2585 val->sType = stype;
2586 val->pNext = vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial_temp(dec);
2587 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial_temp(dec, val);
2588 }
2589
2590 static inline void
vn_replace_VkPhysicalDeviceScalarBlockLayoutFeatures_handle_self(VkPhysicalDeviceScalarBlockLayoutFeatures * val)2591 vn_replace_VkPhysicalDeviceScalarBlockLayoutFeatures_handle_self(VkPhysicalDeviceScalarBlockLayoutFeatures *val)
2592 {
2593 /* skip val->sType */
2594 /* skip val->pNext */
2595 /* skip val->scalarBlockLayout */
2596 }
2597
2598 static inline void
vn_replace_VkPhysicalDeviceScalarBlockLayoutFeatures_handle(VkPhysicalDeviceScalarBlockLayoutFeatures * val)2599 vn_replace_VkPhysicalDeviceScalarBlockLayoutFeatures_handle(VkPhysicalDeviceScalarBlockLayoutFeatures *val)
2600 {
2601 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
2602
2603 do {
2604 switch ((int32_t)pnext->sType) {
2605 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
2606 vn_replace_VkPhysicalDeviceScalarBlockLayoutFeatures_handle_self((VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
2607 break;
2608 default:
2609 /* ignore unknown/unsupported struct */
2610 break;
2611 }
2612 pnext = pnext->pNext;
2613 } while (pnext);
2614 }
2615
2616 /* struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures chain */
2617
2618 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2619 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2620 {
2621 /* no known/supported struct */
2622 vn_encode_simple_pointer(enc, NULL);
2623 }
2624
2625 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)2626 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
2627 {
2628 /* skip val->{sType,pNext} */
2629 vn_encode_VkBool32(enc, &val->uniformBufferStandardLayout);
2630 }
2631
2632 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)2633 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
2634 {
2635 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
2636 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES });
2637 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(enc, val->pNext);
2638 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, val);
2639 }
2640
2641 static inline void *
vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_temp(struct vn_cs_decoder * dec)2642 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_temp(struct vn_cs_decoder *dec)
2643 {
2644 /* no known/supported struct */
2645 if (vn_decode_simple_pointer(dec))
2646 vn_cs_decoder_set_fatal(dec);
2647 return NULL;
2648 }
2649
2650 static inline void
vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)2651 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
2652 {
2653 /* skip val->{sType,pNext} */
2654 vn_decode_VkBool32(dec, &val->uniformBufferStandardLayout);
2655 }
2656
2657 static inline void
vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)2658 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
2659 {
2660 VkStructureType stype;
2661 vn_decode_VkStructureType(dec, &stype);
2662 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES)
2663 vn_cs_decoder_set_fatal(dec);
2664
2665 val->sType = stype;
2666 val->pNext = vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_temp(dec);
2667 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_temp(dec, val);
2668 }
2669
2670 static inline void *
vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial_temp(struct vn_cs_decoder * dec)2671 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial_temp(struct vn_cs_decoder *dec)
2672 {
2673 /* no known/supported struct */
2674 if (vn_decode_simple_pointer(dec))
2675 vn_cs_decoder_set_fatal(dec);
2676 return NULL;
2677 }
2678
2679 static inline void
vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)2680 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
2681 {
2682 /* skip val->{sType,pNext} */
2683 /* skip val->uniformBufferStandardLayout */
2684 }
2685
2686 static inline void
vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)2687 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
2688 {
2689 VkStructureType stype;
2690 vn_decode_VkStructureType(dec, &stype);
2691 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES)
2692 vn_cs_decoder_set_fatal(dec);
2693
2694 val->sType = stype;
2695 val->pNext = vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial_temp(dec);
2696 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial_temp(dec, val);
2697 }
2698
2699 static inline void
vn_replace_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_handle_self(VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)2700 vn_replace_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_handle_self(VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
2701 {
2702 /* skip val->sType */
2703 /* skip val->pNext */
2704 /* skip val->uniformBufferStandardLayout */
2705 }
2706
2707 static inline void
vn_replace_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_handle(VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)2708 vn_replace_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_handle(VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
2709 {
2710 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
2711
2712 do {
2713 switch ((int32_t)pnext->sType) {
2714 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
2715 vn_replace_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_handle_self((VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
2716 break;
2717 default:
2718 /* ignore unknown/unsupported struct */
2719 break;
2720 }
2721 pnext = pnext->pNext;
2722 } while (pnext);
2723 }
2724
2725 /* struct VkPhysicalDeviceBufferDeviceAddressFeatures chain */
2726
2727 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2728 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2729 {
2730 /* no known/supported struct */
2731 vn_encode_simple_pointer(enc, NULL);
2732 }
2733
2734 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceBufferDeviceAddressFeatures * val)2735 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
2736 {
2737 /* skip val->{sType,pNext} */
2738 vn_encode_VkBool32(enc, &val->bufferDeviceAddress);
2739 vn_encode_VkBool32(enc, &val->bufferDeviceAddressCaptureReplay);
2740 vn_encode_VkBool32(enc, &val->bufferDeviceAddressMultiDevice);
2741 }
2742
2743 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceBufferDeviceAddressFeatures * val)2744 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
2745 {
2746 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
2747 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES });
2748 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(enc, val->pNext);
2749 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, val);
2750 }
2751
2752 static inline void *
vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_temp(struct vn_cs_decoder * dec)2753 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_temp(struct vn_cs_decoder *dec)
2754 {
2755 /* no known/supported struct */
2756 if (vn_decode_simple_pointer(dec))
2757 vn_cs_decoder_set_fatal(dec);
2758 return NULL;
2759 }
2760
2761 static inline void
vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceBufferDeviceAddressFeatures * val)2762 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceBufferDeviceAddressFeatures *val)
2763 {
2764 /* skip val->{sType,pNext} */
2765 vn_decode_VkBool32(dec, &val->bufferDeviceAddress);
2766 vn_decode_VkBool32(dec, &val->bufferDeviceAddressCaptureReplay);
2767 vn_decode_VkBool32(dec, &val->bufferDeviceAddressMultiDevice);
2768 }
2769
2770 static inline void
vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceBufferDeviceAddressFeatures * val)2771 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceBufferDeviceAddressFeatures *val)
2772 {
2773 VkStructureType stype;
2774 vn_decode_VkStructureType(dec, &stype);
2775 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES)
2776 vn_cs_decoder_set_fatal(dec);
2777
2778 val->sType = stype;
2779 val->pNext = vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_temp(dec);
2780 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_temp(dec, val);
2781 }
2782
2783 static inline void *
vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial_temp(struct vn_cs_decoder * dec)2784 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial_temp(struct vn_cs_decoder *dec)
2785 {
2786 /* no known/supported struct */
2787 if (vn_decode_simple_pointer(dec))
2788 vn_cs_decoder_set_fatal(dec);
2789 return NULL;
2790 }
2791
2792 static inline void
vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceBufferDeviceAddressFeatures * val)2793 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceBufferDeviceAddressFeatures *val)
2794 {
2795 /* skip val->{sType,pNext} */
2796 /* skip val->bufferDeviceAddress */
2797 /* skip val->bufferDeviceAddressCaptureReplay */
2798 /* skip val->bufferDeviceAddressMultiDevice */
2799 }
2800
2801 static inline void
vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceBufferDeviceAddressFeatures * val)2802 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceBufferDeviceAddressFeatures *val)
2803 {
2804 VkStructureType stype;
2805 vn_decode_VkStructureType(dec, &stype);
2806 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES)
2807 vn_cs_decoder_set_fatal(dec);
2808
2809 val->sType = stype;
2810 val->pNext = vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial_temp(dec);
2811 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial_temp(dec, val);
2812 }
2813
2814 static inline void
vn_replace_VkPhysicalDeviceBufferDeviceAddressFeatures_handle_self(VkPhysicalDeviceBufferDeviceAddressFeatures * val)2815 vn_replace_VkPhysicalDeviceBufferDeviceAddressFeatures_handle_self(VkPhysicalDeviceBufferDeviceAddressFeatures *val)
2816 {
2817 /* skip val->sType */
2818 /* skip val->pNext */
2819 /* skip val->bufferDeviceAddress */
2820 /* skip val->bufferDeviceAddressCaptureReplay */
2821 /* skip val->bufferDeviceAddressMultiDevice */
2822 }
2823
2824 static inline void
vn_replace_VkPhysicalDeviceBufferDeviceAddressFeatures_handle(VkPhysicalDeviceBufferDeviceAddressFeatures * val)2825 vn_replace_VkPhysicalDeviceBufferDeviceAddressFeatures_handle(VkPhysicalDeviceBufferDeviceAddressFeatures *val)
2826 {
2827 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
2828
2829 do {
2830 switch ((int32_t)pnext->sType) {
2831 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
2832 vn_replace_VkPhysicalDeviceBufferDeviceAddressFeatures_handle_self((VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
2833 break;
2834 default:
2835 /* ignore unknown/unsupported struct */
2836 break;
2837 }
2838 pnext = pnext->pNext;
2839 } while (pnext);
2840 }
2841
2842 /* struct VkPhysicalDeviceImagelessFramebufferFeatures chain */
2843
2844 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2845 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_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_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceImagelessFramebufferFeatures * val)2852 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
2853 {
2854 /* skip val->{sType,pNext} */
2855 vn_encode_VkBool32(enc, &val->imagelessFramebuffer);
2856 }
2857
2858 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceImagelessFramebufferFeatures * val)2859 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
2860 {
2861 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
2862 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES });
2863 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(enc, val->pNext);
2864 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, val);
2865 }
2866
2867 static inline void *
vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_temp(struct vn_cs_decoder * dec)2868 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_temp(struct vn_cs_decoder *dec)
2869 {
2870 /* no known/supported struct */
2871 if (vn_decode_simple_pointer(dec))
2872 vn_cs_decoder_set_fatal(dec);
2873 return NULL;
2874 }
2875
2876 static inline void
vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceImagelessFramebufferFeatures * val)2877 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceImagelessFramebufferFeatures *val)
2878 {
2879 /* skip val->{sType,pNext} */
2880 vn_decode_VkBool32(dec, &val->imagelessFramebuffer);
2881 }
2882
2883 static inline void
vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceImagelessFramebufferFeatures * val)2884 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceImagelessFramebufferFeatures *val)
2885 {
2886 VkStructureType stype;
2887 vn_decode_VkStructureType(dec, &stype);
2888 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES)
2889 vn_cs_decoder_set_fatal(dec);
2890
2891 val->sType = stype;
2892 val->pNext = vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_temp(dec);
2893 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self_temp(dec, val);
2894 }
2895
2896 static inline void *
vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial_temp(struct vn_cs_decoder * dec)2897 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial_temp(struct vn_cs_decoder *dec)
2898 {
2899 /* no known/supported struct */
2900 if (vn_decode_simple_pointer(dec))
2901 vn_cs_decoder_set_fatal(dec);
2902 return NULL;
2903 }
2904
2905 static inline void
vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceImagelessFramebufferFeatures * val)2906 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceImagelessFramebufferFeatures *val)
2907 {
2908 /* skip val->{sType,pNext} */
2909 /* skip val->imagelessFramebuffer */
2910 }
2911
2912 static inline void
vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceImagelessFramebufferFeatures * val)2913 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceImagelessFramebufferFeatures *val)
2914 {
2915 VkStructureType stype;
2916 vn_decode_VkStructureType(dec, &stype);
2917 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES)
2918 vn_cs_decoder_set_fatal(dec);
2919
2920 val->sType = stype;
2921 val->pNext = vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial_temp(dec);
2922 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial_temp(dec, val);
2923 }
2924
2925 static inline void
vn_replace_VkPhysicalDeviceImagelessFramebufferFeatures_handle_self(VkPhysicalDeviceImagelessFramebufferFeatures * val)2926 vn_replace_VkPhysicalDeviceImagelessFramebufferFeatures_handle_self(VkPhysicalDeviceImagelessFramebufferFeatures *val)
2927 {
2928 /* skip val->sType */
2929 /* skip val->pNext */
2930 /* skip val->imagelessFramebuffer */
2931 }
2932
2933 static inline void
vn_replace_VkPhysicalDeviceImagelessFramebufferFeatures_handle(VkPhysicalDeviceImagelessFramebufferFeatures * val)2934 vn_replace_VkPhysicalDeviceImagelessFramebufferFeatures_handle(VkPhysicalDeviceImagelessFramebufferFeatures *val)
2935 {
2936 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
2937
2938 do {
2939 switch ((int32_t)pnext->sType) {
2940 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
2941 vn_replace_VkPhysicalDeviceImagelessFramebufferFeatures_handle_self((VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
2942 break;
2943 default:
2944 /* ignore unknown/unsupported struct */
2945 break;
2946 }
2947 pnext = pnext->pNext;
2948 } while (pnext);
2949 }
2950
2951 /* struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures chain */
2952
2953 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2954 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2955 {
2956 /* no known/supported struct */
2957 vn_encode_simple_pointer(enc, NULL);
2958 }
2959
2960 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)2961 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
2962 {
2963 /* skip val->{sType,pNext} */
2964 vn_encode_VkBool32(enc, &val->separateDepthStencilLayouts);
2965 }
2966
2967 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)2968 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
2969 {
2970 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
2971 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES });
2972 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(enc, val->pNext);
2973 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, val);
2974 }
2975
2976 static inline void *
vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_temp(struct vn_cs_decoder * dec)2977 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_temp(struct vn_cs_decoder *dec)
2978 {
2979 /* no known/supported struct */
2980 if (vn_decode_simple_pointer(dec))
2981 vn_cs_decoder_set_fatal(dec);
2982 return NULL;
2983 }
2984
2985 static inline void
vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)2986 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
2987 {
2988 /* skip val->{sType,pNext} */
2989 vn_decode_VkBool32(dec, &val->separateDepthStencilLayouts);
2990 }
2991
2992 static inline void
vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)2993 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
2994 {
2995 VkStructureType stype;
2996 vn_decode_VkStructureType(dec, &stype);
2997 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES)
2998 vn_cs_decoder_set_fatal(dec);
2999
3000 val->sType = stype;
3001 val->pNext = vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_temp(dec);
3002 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_temp(dec, val);
3003 }
3004
3005 static inline void *
vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial_temp(struct vn_cs_decoder * dec)3006 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial_temp(struct vn_cs_decoder *dec)
3007 {
3008 /* no known/supported struct */
3009 if (vn_decode_simple_pointer(dec))
3010 vn_cs_decoder_set_fatal(dec);
3011 return NULL;
3012 }
3013
3014 static inline void
vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3015 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3016 {
3017 /* skip val->{sType,pNext} */
3018 /* skip val->separateDepthStencilLayouts */
3019 }
3020
3021 static inline void
vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3022 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3023 {
3024 VkStructureType stype;
3025 vn_decode_VkStructureType(dec, &stype);
3026 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES)
3027 vn_cs_decoder_set_fatal(dec);
3028
3029 val->sType = stype;
3030 val->pNext = vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial_temp(dec);
3031 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial_temp(dec, val);
3032 }
3033
3034 static inline void
vn_replace_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_handle_self(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3035 vn_replace_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_handle_self(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3036 {
3037 /* skip val->sType */
3038 /* skip val->pNext */
3039 /* skip val->separateDepthStencilLayouts */
3040 }
3041
3042 static inline void
vn_replace_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_handle(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3043 vn_replace_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_handle(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3044 {
3045 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
3046
3047 do {
3048 switch ((int32_t)pnext->sType) {
3049 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
3050 vn_replace_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_handle_self((VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
3051 break;
3052 default:
3053 /* ignore unknown/unsupported struct */
3054 break;
3055 }
3056 pnext = pnext->pNext;
3057 } while (pnext);
3058 }
3059
3060 /* struct VkPhysicalDeviceVulkan11Features chain */
3061
3062 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_encoder * enc,const void * val)3063 vn_encode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_encoder *enc, const void *val)
3064 {
3065 /* no known/supported struct */
3066 vn_encode_simple_pointer(enc, NULL);
3067 }
3068
3069 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Features * val)3070 vn_encode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
3071 {
3072 /* skip val->{sType,pNext} */
3073 vn_encode_VkBool32(enc, &val->storageBuffer16BitAccess);
3074 vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer16BitAccess);
3075 vn_encode_VkBool32(enc, &val->storagePushConstant16);
3076 vn_encode_VkBool32(enc, &val->storageInputOutput16);
3077 vn_encode_VkBool32(enc, &val->multiview);
3078 vn_encode_VkBool32(enc, &val->multiviewGeometryShader);
3079 vn_encode_VkBool32(enc, &val->multiviewTessellationShader);
3080 vn_encode_VkBool32(enc, &val->variablePointersStorageBuffer);
3081 vn_encode_VkBool32(enc, &val->variablePointers);
3082 vn_encode_VkBool32(enc, &val->protectedMemory);
3083 vn_encode_VkBool32(enc, &val->samplerYcbcrConversion);
3084 vn_encode_VkBool32(enc, &val->shaderDrawParameters);
3085 }
3086
3087 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Features * val)3088 vn_encode_VkPhysicalDeviceVulkan11Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
3089 {
3090 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
3091 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES });
3092 vn_encode_VkPhysicalDeviceVulkan11Features_pnext(enc, val->pNext);
3093 vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, val);
3094 }
3095
3096 static inline void *
vn_decode_VkPhysicalDeviceVulkan11Features_pnext_temp(struct vn_cs_decoder * dec)3097 vn_decode_VkPhysicalDeviceVulkan11Features_pnext_temp(struct vn_cs_decoder *dec)
3098 {
3099 /* no known/supported struct */
3100 if (vn_decode_simple_pointer(dec))
3101 vn_cs_decoder_set_fatal(dec);
3102 return NULL;
3103 }
3104
3105 static inline void
vn_decode_VkPhysicalDeviceVulkan11Features_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Features * val)3106 vn_decode_VkPhysicalDeviceVulkan11Features_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Features *val)
3107 {
3108 /* skip val->{sType,pNext} */
3109 vn_decode_VkBool32(dec, &val->storageBuffer16BitAccess);
3110 vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer16BitAccess);
3111 vn_decode_VkBool32(dec, &val->storagePushConstant16);
3112 vn_decode_VkBool32(dec, &val->storageInputOutput16);
3113 vn_decode_VkBool32(dec, &val->multiview);
3114 vn_decode_VkBool32(dec, &val->multiviewGeometryShader);
3115 vn_decode_VkBool32(dec, &val->multiviewTessellationShader);
3116 vn_decode_VkBool32(dec, &val->variablePointersStorageBuffer);
3117 vn_decode_VkBool32(dec, &val->variablePointers);
3118 vn_decode_VkBool32(dec, &val->protectedMemory);
3119 vn_decode_VkBool32(dec, &val->samplerYcbcrConversion);
3120 vn_decode_VkBool32(dec, &val->shaderDrawParameters);
3121 }
3122
3123 static inline void
vn_decode_VkPhysicalDeviceVulkan11Features_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Features * val)3124 vn_decode_VkPhysicalDeviceVulkan11Features_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Features *val)
3125 {
3126 VkStructureType stype;
3127 vn_decode_VkStructureType(dec, &stype);
3128 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES)
3129 vn_cs_decoder_set_fatal(dec);
3130
3131 val->sType = stype;
3132 val->pNext = vn_decode_VkPhysicalDeviceVulkan11Features_pnext_temp(dec);
3133 vn_decode_VkPhysicalDeviceVulkan11Features_self_temp(dec, val);
3134 }
3135
3136 static inline void *
vn_decode_VkPhysicalDeviceVulkan11Features_pnext_partial_temp(struct vn_cs_decoder * dec)3137 vn_decode_VkPhysicalDeviceVulkan11Features_pnext_partial_temp(struct vn_cs_decoder *dec)
3138 {
3139 /* no known/supported struct */
3140 if (vn_decode_simple_pointer(dec))
3141 vn_cs_decoder_set_fatal(dec);
3142 return NULL;
3143 }
3144
3145 static inline void
vn_decode_VkPhysicalDeviceVulkan11Features_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Features * val)3146 vn_decode_VkPhysicalDeviceVulkan11Features_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Features *val)
3147 {
3148 /* skip val->{sType,pNext} */
3149 /* skip val->storageBuffer16BitAccess */
3150 /* skip val->uniformAndStorageBuffer16BitAccess */
3151 /* skip val->storagePushConstant16 */
3152 /* skip val->storageInputOutput16 */
3153 /* skip val->multiview */
3154 /* skip val->multiviewGeometryShader */
3155 /* skip val->multiviewTessellationShader */
3156 /* skip val->variablePointersStorageBuffer */
3157 /* skip val->variablePointers */
3158 /* skip val->protectedMemory */
3159 /* skip val->samplerYcbcrConversion */
3160 /* skip val->shaderDrawParameters */
3161 }
3162
3163 static inline void
vn_decode_VkPhysicalDeviceVulkan11Features_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Features * val)3164 vn_decode_VkPhysicalDeviceVulkan11Features_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Features *val)
3165 {
3166 VkStructureType stype;
3167 vn_decode_VkStructureType(dec, &stype);
3168 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES)
3169 vn_cs_decoder_set_fatal(dec);
3170
3171 val->sType = stype;
3172 val->pNext = vn_decode_VkPhysicalDeviceVulkan11Features_pnext_partial_temp(dec);
3173 vn_decode_VkPhysicalDeviceVulkan11Features_self_partial_temp(dec, val);
3174 }
3175
3176 static inline void
vn_replace_VkPhysicalDeviceVulkan11Features_handle_self(VkPhysicalDeviceVulkan11Features * val)3177 vn_replace_VkPhysicalDeviceVulkan11Features_handle_self(VkPhysicalDeviceVulkan11Features *val)
3178 {
3179 /* skip val->sType */
3180 /* skip val->pNext */
3181 /* skip val->storageBuffer16BitAccess */
3182 /* skip val->uniformAndStorageBuffer16BitAccess */
3183 /* skip val->storagePushConstant16 */
3184 /* skip val->storageInputOutput16 */
3185 /* skip val->multiview */
3186 /* skip val->multiviewGeometryShader */
3187 /* skip val->multiviewTessellationShader */
3188 /* skip val->variablePointersStorageBuffer */
3189 /* skip val->variablePointers */
3190 /* skip val->protectedMemory */
3191 /* skip val->samplerYcbcrConversion */
3192 /* skip val->shaderDrawParameters */
3193 }
3194
3195 static inline void
vn_replace_VkPhysicalDeviceVulkan11Features_handle(VkPhysicalDeviceVulkan11Features * val)3196 vn_replace_VkPhysicalDeviceVulkan11Features_handle(VkPhysicalDeviceVulkan11Features *val)
3197 {
3198 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
3199
3200 do {
3201 switch ((int32_t)pnext->sType) {
3202 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
3203 vn_replace_VkPhysicalDeviceVulkan11Features_handle_self((VkPhysicalDeviceVulkan11Features *)pnext);
3204 break;
3205 default:
3206 /* ignore unknown/unsupported struct */
3207 break;
3208 }
3209 pnext = pnext->pNext;
3210 } while (pnext);
3211 }
3212
3213 /* struct VkPhysicalDeviceVulkan12Features chain */
3214
3215 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_encoder * enc,const void * val)3216 vn_encode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_encoder *enc, const void *val)
3217 {
3218 /* no known/supported struct */
3219 vn_encode_simple_pointer(enc, NULL);
3220 }
3221
3222 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Features * val)3223 vn_encode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
3224 {
3225 /* skip val->{sType,pNext} */
3226 vn_encode_VkBool32(enc, &val->samplerMirrorClampToEdge);
3227 vn_encode_VkBool32(enc, &val->drawIndirectCount);
3228 vn_encode_VkBool32(enc, &val->storageBuffer8BitAccess);
3229 vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer8BitAccess);
3230 vn_encode_VkBool32(enc, &val->storagePushConstant8);
3231 vn_encode_VkBool32(enc, &val->shaderBufferInt64Atomics);
3232 vn_encode_VkBool32(enc, &val->shaderSharedInt64Atomics);
3233 vn_encode_VkBool32(enc, &val->shaderFloat16);
3234 vn_encode_VkBool32(enc, &val->shaderInt8);
3235 vn_encode_VkBool32(enc, &val->descriptorIndexing);
3236 vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayDynamicIndexing);
3237 vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayDynamicIndexing);
3238 vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayDynamicIndexing);
3239 vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayNonUniformIndexing);
3240 vn_encode_VkBool32(enc, &val->shaderSampledImageArrayNonUniformIndexing);
3241 vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayNonUniformIndexing);
3242 vn_encode_VkBool32(enc, &val->shaderStorageImageArrayNonUniformIndexing);
3243 vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayNonUniformIndexing);
3244 vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
3245 vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
3246 vn_encode_VkBool32(enc, &val->descriptorBindingUniformBufferUpdateAfterBind);
3247 vn_encode_VkBool32(enc, &val->descriptorBindingSampledImageUpdateAfterBind);
3248 vn_encode_VkBool32(enc, &val->descriptorBindingStorageImageUpdateAfterBind);
3249 vn_encode_VkBool32(enc, &val->descriptorBindingStorageBufferUpdateAfterBind);
3250 vn_encode_VkBool32(enc, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
3251 vn_encode_VkBool32(enc, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
3252 vn_encode_VkBool32(enc, &val->descriptorBindingUpdateUnusedWhilePending);
3253 vn_encode_VkBool32(enc, &val->descriptorBindingPartiallyBound);
3254 vn_encode_VkBool32(enc, &val->descriptorBindingVariableDescriptorCount);
3255 vn_encode_VkBool32(enc, &val->runtimeDescriptorArray);
3256 vn_encode_VkBool32(enc, &val->samplerFilterMinmax);
3257 vn_encode_VkBool32(enc, &val->scalarBlockLayout);
3258 vn_encode_VkBool32(enc, &val->imagelessFramebuffer);
3259 vn_encode_VkBool32(enc, &val->uniformBufferStandardLayout);
3260 vn_encode_VkBool32(enc, &val->shaderSubgroupExtendedTypes);
3261 vn_encode_VkBool32(enc, &val->separateDepthStencilLayouts);
3262 vn_encode_VkBool32(enc, &val->hostQueryReset);
3263 vn_encode_VkBool32(enc, &val->timelineSemaphore);
3264 vn_encode_VkBool32(enc, &val->bufferDeviceAddress);
3265 vn_encode_VkBool32(enc, &val->bufferDeviceAddressCaptureReplay);
3266 vn_encode_VkBool32(enc, &val->bufferDeviceAddressMultiDevice);
3267 vn_encode_VkBool32(enc, &val->vulkanMemoryModel);
3268 vn_encode_VkBool32(enc, &val->vulkanMemoryModelDeviceScope);
3269 vn_encode_VkBool32(enc, &val->vulkanMemoryModelAvailabilityVisibilityChains);
3270 vn_encode_VkBool32(enc, &val->shaderOutputViewportIndex);
3271 vn_encode_VkBool32(enc, &val->shaderOutputLayer);
3272 vn_encode_VkBool32(enc, &val->subgroupBroadcastDynamicId);
3273 }
3274
3275 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Features * val)3276 vn_encode_VkPhysicalDeviceVulkan12Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
3277 {
3278 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
3279 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES });
3280 vn_encode_VkPhysicalDeviceVulkan12Features_pnext(enc, val->pNext);
3281 vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, val);
3282 }
3283
3284 static inline void *
vn_decode_VkPhysicalDeviceVulkan12Features_pnext_temp(struct vn_cs_decoder * dec)3285 vn_decode_VkPhysicalDeviceVulkan12Features_pnext_temp(struct vn_cs_decoder *dec)
3286 {
3287 /* no known/supported struct */
3288 if (vn_decode_simple_pointer(dec))
3289 vn_cs_decoder_set_fatal(dec);
3290 return NULL;
3291 }
3292
3293 static inline void
vn_decode_VkPhysicalDeviceVulkan12Features_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Features * val)3294 vn_decode_VkPhysicalDeviceVulkan12Features_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Features *val)
3295 {
3296 /* skip val->{sType,pNext} */
3297 vn_decode_VkBool32(dec, &val->samplerMirrorClampToEdge);
3298 vn_decode_VkBool32(dec, &val->drawIndirectCount);
3299 vn_decode_VkBool32(dec, &val->storageBuffer8BitAccess);
3300 vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer8BitAccess);
3301 vn_decode_VkBool32(dec, &val->storagePushConstant8);
3302 vn_decode_VkBool32(dec, &val->shaderBufferInt64Atomics);
3303 vn_decode_VkBool32(dec, &val->shaderSharedInt64Atomics);
3304 vn_decode_VkBool32(dec, &val->shaderFloat16);
3305 vn_decode_VkBool32(dec, &val->shaderInt8);
3306 vn_decode_VkBool32(dec, &val->descriptorIndexing);
3307 vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayDynamicIndexing);
3308 vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayDynamicIndexing);
3309 vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayDynamicIndexing);
3310 vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexing);
3311 vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexing);
3312 vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexing);
3313 vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexing);
3314 vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexing);
3315 vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
3316 vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
3317 vn_decode_VkBool32(dec, &val->descriptorBindingUniformBufferUpdateAfterBind);
3318 vn_decode_VkBool32(dec, &val->descriptorBindingSampledImageUpdateAfterBind);
3319 vn_decode_VkBool32(dec, &val->descriptorBindingStorageImageUpdateAfterBind);
3320 vn_decode_VkBool32(dec, &val->descriptorBindingStorageBufferUpdateAfterBind);
3321 vn_decode_VkBool32(dec, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
3322 vn_decode_VkBool32(dec, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
3323 vn_decode_VkBool32(dec, &val->descriptorBindingUpdateUnusedWhilePending);
3324 vn_decode_VkBool32(dec, &val->descriptorBindingPartiallyBound);
3325 vn_decode_VkBool32(dec, &val->descriptorBindingVariableDescriptorCount);
3326 vn_decode_VkBool32(dec, &val->runtimeDescriptorArray);
3327 vn_decode_VkBool32(dec, &val->samplerFilterMinmax);
3328 vn_decode_VkBool32(dec, &val->scalarBlockLayout);
3329 vn_decode_VkBool32(dec, &val->imagelessFramebuffer);
3330 vn_decode_VkBool32(dec, &val->uniformBufferStandardLayout);
3331 vn_decode_VkBool32(dec, &val->shaderSubgroupExtendedTypes);
3332 vn_decode_VkBool32(dec, &val->separateDepthStencilLayouts);
3333 vn_decode_VkBool32(dec, &val->hostQueryReset);
3334 vn_decode_VkBool32(dec, &val->timelineSemaphore);
3335 vn_decode_VkBool32(dec, &val->bufferDeviceAddress);
3336 vn_decode_VkBool32(dec, &val->bufferDeviceAddressCaptureReplay);
3337 vn_decode_VkBool32(dec, &val->bufferDeviceAddressMultiDevice);
3338 vn_decode_VkBool32(dec, &val->vulkanMemoryModel);
3339 vn_decode_VkBool32(dec, &val->vulkanMemoryModelDeviceScope);
3340 vn_decode_VkBool32(dec, &val->vulkanMemoryModelAvailabilityVisibilityChains);
3341 vn_decode_VkBool32(dec, &val->shaderOutputViewportIndex);
3342 vn_decode_VkBool32(dec, &val->shaderOutputLayer);
3343 vn_decode_VkBool32(dec, &val->subgroupBroadcastDynamicId);
3344 }
3345
3346 static inline void
vn_decode_VkPhysicalDeviceVulkan12Features_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Features * val)3347 vn_decode_VkPhysicalDeviceVulkan12Features_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Features *val)
3348 {
3349 VkStructureType stype;
3350 vn_decode_VkStructureType(dec, &stype);
3351 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES)
3352 vn_cs_decoder_set_fatal(dec);
3353
3354 val->sType = stype;
3355 val->pNext = vn_decode_VkPhysicalDeviceVulkan12Features_pnext_temp(dec);
3356 vn_decode_VkPhysicalDeviceVulkan12Features_self_temp(dec, val);
3357 }
3358
3359 static inline void *
vn_decode_VkPhysicalDeviceVulkan12Features_pnext_partial_temp(struct vn_cs_decoder * dec)3360 vn_decode_VkPhysicalDeviceVulkan12Features_pnext_partial_temp(struct vn_cs_decoder *dec)
3361 {
3362 /* no known/supported struct */
3363 if (vn_decode_simple_pointer(dec))
3364 vn_cs_decoder_set_fatal(dec);
3365 return NULL;
3366 }
3367
3368 static inline void
vn_decode_VkPhysicalDeviceVulkan12Features_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Features * val)3369 vn_decode_VkPhysicalDeviceVulkan12Features_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Features *val)
3370 {
3371 /* skip val->{sType,pNext} */
3372 /* skip val->samplerMirrorClampToEdge */
3373 /* skip val->drawIndirectCount */
3374 /* skip val->storageBuffer8BitAccess */
3375 /* skip val->uniformAndStorageBuffer8BitAccess */
3376 /* skip val->storagePushConstant8 */
3377 /* skip val->shaderBufferInt64Atomics */
3378 /* skip val->shaderSharedInt64Atomics */
3379 /* skip val->shaderFloat16 */
3380 /* skip val->shaderInt8 */
3381 /* skip val->descriptorIndexing */
3382 /* skip val->shaderInputAttachmentArrayDynamicIndexing */
3383 /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
3384 /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
3385 /* skip val->shaderUniformBufferArrayNonUniformIndexing */
3386 /* skip val->shaderSampledImageArrayNonUniformIndexing */
3387 /* skip val->shaderStorageBufferArrayNonUniformIndexing */
3388 /* skip val->shaderStorageImageArrayNonUniformIndexing */
3389 /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
3390 /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
3391 /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
3392 /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
3393 /* skip val->descriptorBindingSampledImageUpdateAfterBind */
3394 /* skip val->descriptorBindingStorageImageUpdateAfterBind */
3395 /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
3396 /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
3397 /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
3398 /* skip val->descriptorBindingUpdateUnusedWhilePending */
3399 /* skip val->descriptorBindingPartiallyBound */
3400 /* skip val->descriptorBindingVariableDescriptorCount */
3401 /* skip val->runtimeDescriptorArray */
3402 /* skip val->samplerFilterMinmax */
3403 /* skip val->scalarBlockLayout */
3404 /* skip val->imagelessFramebuffer */
3405 /* skip val->uniformBufferStandardLayout */
3406 /* skip val->shaderSubgroupExtendedTypes */
3407 /* skip val->separateDepthStencilLayouts */
3408 /* skip val->hostQueryReset */
3409 /* skip val->timelineSemaphore */
3410 /* skip val->bufferDeviceAddress */
3411 /* skip val->bufferDeviceAddressCaptureReplay */
3412 /* skip val->bufferDeviceAddressMultiDevice */
3413 /* skip val->vulkanMemoryModel */
3414 /* skip val->vulkanMemoryModelDeviceScope */
3415 /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
3416 /* skip val->shaderOutputViewportIndex */
3417 /* skip val->shaderOutputLayer */
3418 /* skip val->subgroupBroadcastDynamicId */
3419 }
3420
3421 static inline void
vn_decode_VkPhysicalDeviceVulkan12Features_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Features * val)3422 vn_decode_VkPhysicalDeviceVulkan12Features_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Features *val)
3423 {
3424 VkStructureType stype;
3425 vn_decode_VkStructureType(dec, &stype);
3426 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES)
3427 vn_cs_decoder_set_fatal(dec);
3428
3429 val->sType = stype;
3430 val->pNext = vn_decode_VkPhysicalDeviceVulkan12Features_pnext_partial_temp(dec);
3431 vn_decode_VkPhysicalDeviceVulkan12Features_self_partial_temp(dec, val);
3432 }
3433
3434 static inline void
vn_replace_VkPhysicalDeviceVulkan12Features_handle_self(VkPhysicalDeviceVulkan12Features * val)3435 vn_replace_VkPhysicalDeviceVulkan12Features_handle_self(VkPhysicalDeviceVulkan12Features *val)
3436 {
3437 /* skip val->sType */
3438 /* skip val->pNext */
3439 /* skip val->samplerMirrorClampToEdge */
3440 /* skip val->drawIndirectCount */
3441 /* skip val->storageBuffer8BitAccess */
3442 /* skip val->uniformAndStorageBuffer8BitAccess */
3443 /* skip val->storagePushConstant8 */
3444 /* skip val->shaderBufferInt64Atomics */
3445 /* skip val->shaderSharedInt64Atomics */
3446 /* skip val->shaderFloat16 */
3447 /* skip val->shaderInt8 */
3448 /* skip val->descriptorIndexing */
3449 /* skip val->shaderInputAttachmentArrayDynamicIndexing */
3450 /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
3451 /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
3452 /* skip val->shaderUniformBufferArrayNonUniformIndexing */
3453 /* skip val->shaderSampledImageArrayNonUniformIndexing */
3454 /* skip val->shaderStorageBufferArrayNonUniformIndexing */
3455 /* skip val->shaderStorageImageArrayNonUniformIndexing */
3456 /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
3457 /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
3458 /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
3459 /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
3460 /* skip val->descriptorBindingSampledImageUpdateAfterBind */
3461 /* skip val->descriptorBindingStorageImageUpdateAfterBind */
3462 /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
3463 /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
3464 /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
3465 /* skip val->descriptorBindingUpdateUnusedWhilePending */
3466 /* skip val->descriptorBindingPartiallyBound */
3467 /* skip val->descriptorBindingVariableDescriptorCount */
3468 /* skip val->runtimeDescriptorArray */
3469 /* skip val->samplerFilterMinmax */
3470 /* skip val->scalarBlockLayout */
3471 /* skip val->imagelessFramebuffer */
3472 /* skip val->uniformBufferStandardLayout */
3473 /* skip val->shaderSubgroupExtendedTypes */
3474 /* skip val->separateDepthStencilLayouts */
3475 /* skip val->hostQueryReset */
3476 /* skip val->timelineSemaphore */
3477 /* skip val->bufferDeviceAddress */
3478 /* skip val->bufferDeviceAddressCaptureReplay */
3479 /* skip val->bufferDeviceAddressMultiDevice */
3480 /* skip val->vulkanMemoryModel */
3481 /* skip val->vulkanMemoryModelDeviceScope */
3482 /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
3483 /* skip val->shaderOutputViewportIndex */
3484 /* skip val->shaderOutputLayer */
3485 /* skip val->subgroupBroadcastDynamicId */
3486 }
3487
3488 static inline void
vn_replace_VkPhysicalDeviceVulkan12Features_handle(VkPhysicalDeviceVulkan12Features * val)3489 vn_replace_VkPhysicalDeviceVulkan12Features_handle(VkPhysicalDeviceVulkan12Features *val)
3490 {
3491 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
3492
3493 do {
3494 switch ((int32_t)pnext->sType) {
3495 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
3496 vn_replace_VkPhysicalDeviceVulkan12Features_handle_self((VkPhysicalDeviceVulkan12Features *)pnext);
3497 break;
3498 default:
3499 /* ignore unknown/unsupported struct */
3500 break;
3501 }
3502 pnext = pnext->pNext;
3503 } while (pnext);
3504 }
3505
3506 /* struct VkPhysicalDeviceFeatures2 chain */
3507
3508 static inline void
vn_encode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_encoder * enc,const void * val)3509 vn_encode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_encoder *enc, const void *val)
3510 {
3511 const VkBaseInStructure *pnext = val;
3512
3513 while (pnext) {
3514 switch ((int32_t)pnext->sType) {
3515 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
3516 vn_encode_simple_pointer(enc, pnext);
3517 vn_encode_VkStructureType(enc, &pnext->sType);
3518 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3519 vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext);
3520 return;
3521 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
3522 vn_encode_simple_pointer(enc, pnext);
3523 vn_encode_VkStructureType(enc, &pnext->sType);
3524 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3525 vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext);
3526 return;
3527 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
3528 vn_encode_simple_pointer(enc, pnext);
3529 vn_encode_VkStructureType(enc, &pnext->sType);
3530 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3531 vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext);
3532 return;
3533 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
3534 vn_encode_simple_pointer(enc, pnext);
3535 vn_encode_VkStructureType(enc, &pnext->sType);
3536 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3537 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
3538 return;
3539 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
3540 vn_encode_simple_pointer(enc, pnext);
3541 vn_encode_VkStructureType(enc, &pnext->sType);
3542 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3543 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
3544 return;
3545 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
3546 vn_encode_simple_pointer(enc, pnext);
3547 vn_encode_VkStructureType(enc, &pnext->sType);
3548 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3549 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
3550 return;
3551 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
3552 vn_encode_simple_pointer(enc, pnext);
3553 vn_encode_VkStructureType(enc, &pnext->sType);
3554 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3555 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
3556 return;
3557 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
3558 vn_encode_simple_pointer(enc, pnext);
3559 vn_encode_VkStructureType(enc, &pnext->sType);
3560 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3561 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
3562 return;
3563 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
3564 vn_encode_simple_pointer(enc, pnext);
3565 vn_encode_VkStructureType(enc, &pnext->sType);
3566 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3567 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
3568 return;
3569 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
3570 vn_encode_simple_pointer(enc, pnext);
3571 vn_encode_VkStructureType(enc, &pnext->sType);
3572 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3573 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
3574 return;
3575 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
3576 vn_encode_simple_pointer(enc, pnext);
3577 vn_encode_VkStructureType(enc, &pnext->sType);
3578 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3579 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
3580 return;
3581 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
3582 vn_encode_simple_pointer(enc, pnext);
3583 vn_encode_VkStructureType(enc, &pnext->sType);
3584 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3585 vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext);
3586 return;
3587 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
3588 vn_encode_simple_pointer(enc, pnext);
3589 vn_encode_VkStructureType(enc, &pnext->sType);
3590 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3591 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
3592 return;
3593 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
3594 vn_encode_simple_pointer(enc, pnext);
3595 vn_encode_VkStructureType(enc, &pnext->sType);
3596 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3597 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
3598 return;
3599 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
3600 vn_encode_simple_pointer(enc, pnext);
3601 vn_encode_VkStructureType(enc, &pnext->sType);
3602 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3603 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
3604 return;
3605 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
3606 vn_encode_simple_pointer(enc, pnext);
3607 vn_encode_VkStructureType(enc, &pnext->sType);
3608 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3609 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
3610 return;
3611 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
3612 vn_encode_simple_pointer(enc, pnext);
3613 vn_encode_VkStructureType(enc, &pnext->sType);
3614 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3615 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
3616 return;
3617 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
3618 vn_encode_simple_pointer(enc, pnext);
3619 vn_encode_VkStructureType(enc, &pnext->sType);
3620 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3621 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
3622 return;
3623 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
3624 vn_encode_simple_pointer(enc, pnext);
3625 vn_encode_VkStructureType(enc, &pnext->sType);
3626 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3627 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
3628 return;
3629 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
3630 vn_encode_simple_pointer(enc, pnext);
3631 vn_encode_VkStructureType(enc, &pnext->sType);
3632 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3633 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
3634 return;
3635 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
3636 vn_encode_simple_pointer(enc, pnext);
3637 vn_encode_VkStructureType(enc, &pnext->sType);
3638 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3639 vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, (const VkPhysicalDeviceVulkan11Features *)pnext);
3640 return;
3641 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
3642 vn_encode_simple_pointer(enc, pnext);
3643 vn_encode_VkStructureType(enc, &pnext->sType);
3644 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
3645 vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, (const VkPhysicalDeviceVulkan12Features *)pnext);
3646 return;
3647 default:
3648 /* ignore unknown/unsupported struct */
3649 break;
3650 }
3651 pnext = pnext->pNext;
3652 }
3653
3654 vn_encode_simple_pointer(enc, NULL);
3655 }
3656
3657 static inline void
vn_encode_VkPhysicalDeviceFeatures2_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures2 * val)3658 vn_encode_VkPhysicalDeviceFeatures2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
3659 {
3660 /* skip val->{sType,pNext} */
3661 vn_encode_VkPhysicalDeviceFeatures(enc, &val->features);
3662 }
3663
3664 static inline void
vn_encode_VkPhysicalDeviceFeatures2(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures2 * val)3665 vn_encode_VkPhysicalDeviceFeatures2(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
3666 {
3667 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
3668 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 });
3669 vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, val->pNext);
3670 vn_encode_VkPhysicalDeviceFeatures2_self(enc, val);
3671 }
3672
3673 static inline void *
vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(struct vn_cs_decoder * dec)3674 vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(struct vn_cs_decoder *dec)
3675 {
3676 VkBaseOutStructure *pnext;
3677 VkStructureType stype;
3678
3679 if (!vn_decode_simple_pointer(dec))
3680 return NULL;
3681
3682 vn_decode_VkStructureType(dec, &stype);
3683 switch ((int32_t)stype) {
3684 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
3685 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceVariablePointersFeatures));
3686 if (pnext) {
3687 pnext->sType = stype;
3688 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3689 vn_decode_VkPhysicalDeviceVariablePointersFeatures_self_temp(dec, (VkPhysicalDeviceVariablePointersFeatures *)pnext);
3690 }
3691 break;
3692 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
3693 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceMultiviewFeatures));
3694 if (pnext) {
3695 pnext->sType = stype;
3696 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3697 vn_decode_VkPhysicalDeviceMultiviewFeatures_self_temp(dec, (VkPhysicalDeviceMultiviewFeatures *)pnext);
3698 }
3699 break;
3700 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
3701 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDevice16BitStorageFeatures));
3702 if (pnext) {
3703 pnext->sType = stype;
3704 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3705 vn_decode_VkPhysicalDevice16BitStorageFeatures_self_temp(dec, (VkPhysicalDevice16BitStorageFeatures *)pnext);
3706 }
3707 break;
3708 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
3709 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures));
3710 if (pnext) {
3711 pnext->sType = stype;
3712 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3713 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_temp(dec, (VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
3714 }
3715 break;
3716 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
3717 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures));
3718 if (pnext) {
3719 pnext->sType = stype;
3720 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3721 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_temp(dec, (VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
3722 }
3723 break;
3724 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
3725 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceProtectedMemoryFeatures));
3726 if (pnext) {
3727 pnext->sType = stype;
3728 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3729 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self_temp(dec, (VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
3730 }
3731 break;
3732 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
3733 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceShaderDrawParametersFeatures));
3734 if (pnext) {
3735 pnext->sType = stype;
3736 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3737 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self_temp(dec, (VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
3738 }
3739 break;
3740 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
3741 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceShaderFloat16Int8Features));
3742 if (pnext) {
3743 pnext->sType = stype;
3744 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3745 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self_temp(dec, (VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
3746 }
3747 break;
3748 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
3749 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceHostQueryResetFeatures));
3750 if (pnext) {
3751 pnext->sType = stype;
3752 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3753 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self_temp(dec, (VkPhysicalDeviceHostQueryResetFeatures *)pnext);
3754 }
3755 break;
3756 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
3757 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceDescriptorIndexingFeatures));
3758 if (pnext) {
3759 pnext->sType = stype;
3760 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3761 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self_temp(dec, (VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
3762 }
3763 break;
3764 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
3765 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceTimelineSemaphoreFeatures));
3766 if (pnext) {
3767 pnext->sType = stype;
3768 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3769 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_temp(dec, (VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
3770 }
3771 break;
3772 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
3773 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDevice8BitStorageFeatures));
3774 if (pnext) {
3775 pnext->sType = stype;
3776 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3777 vn_decode_VkPhysicalDevice8BitStorageFeatures_self_temp(dec, (VkPhysicalDevice8BitStorageFeatures *)pnext);
3778 }
3779 break;
3780 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
3781 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceVulkanMemoryModelFeatures));
3782 if (pnext) {
3783 pnext->sType = stype;
3784 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3785 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_temp(dec, (VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
3786 }
3787 break;
3788 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
3789 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceShaderAtomicInt64Features));
3790 if (pnext) {
3791 pnext->sType = stype;
3792 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3793 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self_temp(dec, (VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
3794 }
3795 break;
3796 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
3797 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceTransformFeedbackFeaturesEXT));
3798 if (pnext) {
3799 pnext->sType = stype;
3800 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3801 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_temp(dec, (VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
3802 }
3803 break;
3804 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
3805 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceScalarBlockLayoutFeatures));
3806 if (pnext) {
3807 pnext->sType = stype;
3808 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3809 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_temp(dec, (VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
3810 }
3811 break;
3812 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
3813 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceUniformBufferStandardLayoutFeatures));
3814 if (pnext) {
3815 pnext->sType = stype;
3816 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3817 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_temp(dec, (VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
3818 }
3819 break;
3820 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
3821 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceBufferDeviceAddressFeatures));
3822 if (pnext) {
3823 pnext->sType = stype;
3824 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3825 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_temp(dec, (VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
3826 }
3827 break;
3828 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
3829 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceImagelessFramebufferFeatures));
3830 if (pnext) {
3831 pnext->sType = stype;
3832 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3833 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self_temp(dec, (VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
3834 }
3835 break;
3836 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
3837 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures));
3838 if (pnext) {
3839 pnext->sType = stype;
3840 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3841 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_temp(dec, (VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
3842 }
3843 break;
3844 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
3845 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceVulkan11Features));
3846 if (pnext) {
3847 pnext->sType = stype;
3848 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3849 vn_decode_VkPhysicalDeviceVulkan11Features_self_temp(dec, (VkPhysicalDeviceVulkan11Features *)pnext);
3850 }
3851 break;
3852 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
3853 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceVulkan12Features));
3854 if (pnext) {
3855 pnext->sType = stype;
3856 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3857 vn_decode_VkPhysicalDeviceVulkan12Features_self_temp(dec, (VkPhysicalDeviceVulkan12Features *)pnext);
3858 }
3859 break;
3860 default:
3861 /* unexpected struct */
3862 pnext = NULL;
3863 vn_cs_decoder_set_fatal(dec);
3864 break;
3865 }
3866
3867 return pnext;
3868 }
3869
3870 static inline void
vn_decode_VkPhysicalDeviceFeatures2_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceFeatures2 * val)3871 vn_decode_VkPhysicalDeviceFeatures2_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures2 *val)
3872 {
3873 /* skip val->{sType,pNext} */
3874 vn_decode_VkPhysicalDeviceFeatures_temp(dec, &val->features);
3875 }
3876
3877 static inline void
vn_decode_VkPhysicalDeviceFeatures2_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceFeatures2 * val)3878 vn_decode_VkPhysicalDeviceFeatures2_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures2 *val)
3879 {
3880 VkStructureType stype;
3881 vn_decode_VkStructureType(dec, &stype);
3882 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2)
3883 vn_cs_decoder_set_fatal(dec);
3884
3885 val->sType = stype;
3886 val->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_temp(dec);
3887 vn_decode_VkPhysicalDeviceFeatures2_self_temp(dec, val);
3888 }
3889
3890 static inline void *
vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(struct vn_cs_decoder * dec)3891 vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(struct vn_cs_decoder *dec)
3892 {
3893 VkBaseOutStructure *pnext;
3894 VkStructureType stype;
3895
3896 if (!vn_decode_simple_pointer(dec))
3897 return NULL;
3898
3899 vn_decode_VkStructureType(dec, &stype);
3900 switch ((int32_t)stype) {
3901 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
3902 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceVariablePointersFeatures));
3903 if (pnext) {
3904 pnext->sType = stype;
3905 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
3906 vn_decode_VkPhysicalDeviceVariablePointersFeatures_self_partial_temp(dec, (VkPhysicalDeviceVariablePointersFeatures *)pnext);
3907 }
3908 break;
3909 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
3910 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceMultiviewFeatures));
3911 if (pnext) {
3912 pnext->sType = stype;
3913 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
3914 vn_decode_VkPhysicalDeviceMultiviewFeatures_self_partial_temp(dec, (VkPhysicalDeviceMultiviewFeatures *)pnext);
3915 }
3916 break;
3917 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
3918 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDevice16BitStorageFeatures));
3919 if (pnext) {
3920 pnext->sType = stype;
3921 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
3922 vn_decode_VkPhysicalDevice16BitStorageFeatures_self_partial_temp(dec, (VkPhysicalDevice16BitStorageFeatures *)pnext);
3923 }
3924 break;
3925 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
3926 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures));
3927 if (pnext) {
3928 pnext->sType = stype;
3929 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
3930 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial_temp(dec, (VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
3931 }
3932 break;
3933 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
3934 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures));
3935 if (pnext) {
3936 pnext->sType = stype;
3937 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
3938 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial_temp(dec, (VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
3939 }
3940 break;
3941 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
3942 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceProtectedMemoryFeatures));
3943 if (pnext) {
3944 pnext->sType = stype;
3945 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
3946 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial_temp(dec, (VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
3947 }
3948 break;
3949 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
3950 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceShaderDrawParametersFeatures));
3951 if (pnext) {
3952 pnext->sType = stype;
3953 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
3954 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial_temp(dec, (VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
3955 }
3956 break;
3957 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
3958 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceShaderFloat16Int8Features));
3959 if (pnext) {
3960 pnext->sType = stype;
3961 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
3962 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial_temp(dec, (VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
3963 }
3964 break;
3965 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
3966 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceHostQueryResetFeatures));
3967 if (pnext) {
3968 pnext->sType = stype;
3969 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
3970 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self_partial_temp(dec, (VkPhysicalDeviceHostQueryResetFeatures *)pnext);
3971 }
3972 break;
3973 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
3974 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceDescriptorIndexingFeatures));
3975 if (pnext) {
3976 pnext->sType = stype;
3977 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
3978 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial_temp(dec, (VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
3979 }
3980 break;
3981 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
3982 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceTimelineSemaphoreFeatures));
3983 if (pnext) {
3984 pnext->sType = stype;
3985 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
3986 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial_temp(dec, (VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
3987 }
3988 break;
3989 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
3990 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDevice8BitStorageFeatures));
3991 if (pnext) {
3992 pnext->sType = stype;
3993 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
3994 vn_decode_VkPhysicalDevice8BitStorageFeatures_self_partial_temp(dec, (VkPhysicalDevice8BitStorageFeatures *)pnext);
3995 }
3996 break;
3997 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
3998 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceVulkanMemoryModelFeatures));
3999 if (pnext) {
4000 pnext->sType = stype;
4001 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
4002 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial_temp(dec, (VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
4003 }
4004 break;
4005 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
4006 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceShaderAtomicInt64Features));
4007 if (pnext) {
4008 pnext->sType = stype;
4009 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
4010 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial_temp(dec, (VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
4011 }
4012 break;
4013 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
4014 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceTransformFeedbackFeaturesEXT));
4015 if (pnext) {
4016 pnext->sType = stype;
4017 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
4018 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial_temp(dec, (VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
4019 }
4020 break;
4021 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
4022 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceScalarBlockLayoutFeatures));
4023 if (pnext) {
4024 pnext->sType = stype;
4025 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
4026 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial_temp(dec, (VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
4027 }
4028 break;
4029 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
4030 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceUniformBufferStandardLayoutFeatures));
4031 if (pnext) {
4032 pnext->sType = stype;
4033 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
4034 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial_temp(dec, (VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
4035 }
4036 break;
4037 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
4038 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceBufferDeviceAddressFeatures));
4039 if (pnext) {
4040 pnext->sType = stype;
4041 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
4042 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial_temp(dec, (VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
4043 }
4044 break;
4045 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
4046 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceImagelessFramebufferFeatures));
4047 if (pnext) {
4048 pnext->sType = stype;
4049 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
4050 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial_temp(dec, (VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
4051 }
4052 break;
4053 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
4054 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures));
4055 if (pnext) {
4056 pnext->sType = stype;
4057 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
4058 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial_temp(dec, (VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
4059 }
4060 break;
4061 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
4062 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceVulkan11Features));
4063 if (pnext) {
4064 pnext->sType = stype;
4065 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
4066 vn_decode_VkPhysicalDeviceVulkan11Features_self_partial_temp(dec, (VkPhysicalDeviceVulkan11Features *)pnext);
4067 }
4068 break;
4069 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
4070 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceVulkan12Features));
4071 if (pnext) {
4072 pnext->sType = stype;
4073 pnext->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
4074 vn_decode_VkPhysicalDeviceVulkan12Features_self_partial_temp(dec, (VkPhysicalDeviceVulkan12Features *)pnext);
4075 }
4076 break;
4077 default:
4078 /* unexpected struct */
4079 pnext = NULL;
4080 vn_cs_decoder_set_fatal(dec);
4081 break;
4082 }
4083
4084 return pnext;
4085 }
4086
4087 static inline void
vn_decode_VkPhysicalDeviceFeatures2_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceFeatures2 * val)4088 vn_decode_VkPhysicalDeviceFeatures2_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures2 *val)
4089 {
4090 /* skip val->{sType,pNext} */
4091 vn_decode_VkPhysicalDeviceFeatures_partial_temp(dec, &val->features);
4092 }
4093
4094 static inline void
vn_decode_VkPhysicalDeviceFeatures2_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceFeatures2 * val)4095 vn_decode_VkPhysicalDeviceFeatures2_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures2 *val)
4096 {
4097 VkStructureType stype;
4098 vn_decode_VkStructureType(dec, &stype);
4099 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2)
4100 vn_cs_decoder_set_fatal(dec);
4101
4102 val->sType = stype;
4103 val->pNext = vn_decode_VkPhysicalDeviceFeatures2_pnext_partial_temp(dec);
4104 vn_decode_VkPhysicalDeviceFeatures2_self_partial_temp(dec, val);
4105 }
4106
4107 static inline void
vn_replace_VkPhysicalDeviceFeatures2_handle_self(VkPhysicalDeviceFeatures2 * val)4108 vn_replace_VkPhysicalDeviceFeatures2_handle_self(VkPhysicalDeviceFeatures2 *val)
4109 {
4110 /* skip val->sType */
4111 /* skip val->pNext */
4112 vn_replace_VkPhysicalDeviceFeatures_handle(&val->features);
4113 }
4114
4115 static inline void
vn_replace_VkPhysicalDeviceFeatures2_handle(VkPhysicalDeviceFeatures2 * val)4116 vn_replace_VkPhysicalDeviceFeatures2_handle(VkPhysicalDeviceFeatures2 *val)
4117 {
4118 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
4119
4120 do {
4121 switch ((int32_t)pnext->sType) {
4122 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
4123 vn_replace_VkPhysicalDeviceFeatures2_handle_self((VkPhysicalDeviceFeatures2 *)pnext);
4124 break;
4125 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
4126 vn_replace_VkPhysicalDeviceVariablePointersFeatures_handle_self((VkPhysicalDeviceVariablePointersFeatures *)pnext);
4127 break;
4128 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
4129 vn_replace_VkPhysicalDeviceMultiviewFeatures_handle_self((VkPhysicalDeviceMultiviewFeatures *)pnext);
4130 break;
4131 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
4132 vn_replace_VkPhysicalDevice16BitStorageFeatures_handle_self((VkPhysicalDevice16BitStorageFeatures *)pnext);
4133 break;
4134 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
4135 vn_replace_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_handle_self((VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
4136 break;
4137 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
4138 vn_replace_VkPhysicalDeviceSamplerYcbcrConversionFeatures_handle_self((VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
4139 break;
4140 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
4141 vn_replace_VkPhysicalDeviceProtectedMemoryFeatures_handle_self((VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
4142 break;
4143 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
4144 vn_replace_VkPhysicalDeviceShaderDrawParametersFeatures_handle_self((VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
4145 break;
4146 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
4147 vn_replace_VkPhysicalDeviceShaderFloat16Int8Features_handle_self((VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
4148 break;
4149 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
4150 vn_replace_VkPhysicalDeviceHostQueryResetFeatures_handle_self((VkPhysicalDeviceHostQueryResetFeatures *)pnext);
4151 break;
4152 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
4153 vn_replace_VkPhysicalDeviceDescriptorIndexingFeatures_handle_self((VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
4154 break;
4155 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
4156 vn_replace_VkPhysicalDeviceTimelineSemaphoreFeatures_handle_self((VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
4157 break;
4158 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
4159 vn_replace_VkPhysicalDevice8BitStorageFeatures_handle_self((VkPhysicalDevice8BitStorageFeatures *)pnext);
4160 break;
4161 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
4162 vn_replace_VkPhysicalDeviceVulkanMemoryModelFeatures_handle_self((VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
4163 break;
4164 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
4165 vn_replace_VkPhysicalDeviceShaderAtomicInt64Features_handle_self((VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
4166 break;
4167 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
4168 vn_replace_VkPhysicalDeviceTransformFeedbackFeaturesEXT_handle_self((VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
4169 break;
4170 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
4171 vn_replace_VkPhysicalDeviceScalarBlockLayoutFeatures_handle_self((VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
4172 break;
4173 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
4174 vn_replace_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_handle_self((VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
4175 break;
4176 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
4177 vn_replace_VkPhysicalDeviceBufferDeviceAddressFeatures_handle_self((VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
4178 break;
4179 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
4180 vn_replace_VkPhysicalDeviceImagelessFramebufferFeatures_handle_self((VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
4181 break;
4182 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
4183 vn_replace_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_handle_self((VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
4184 break;
4185 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
4186 vn_replace_VkPhysicalDeviceVulkan11Features_handle_self((VkPhysicalDeviceVulkan11Features *)pnext);
4187 break;
4188 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
4189 vn_replace_VkPhysicalDeviceVulkan12Features_handle_self((VkPhysicalDeviceVulkan12Features *)pnext);
4190 break;
4191 default:
4192 /* ignore unknown/unsupported struct */
4193 break;
4194 }
4195 pnext = pnext->pNext;
4196 } while (pnext);
4197 }
4198
4199 /* struct VkDeviceGroupDeviceCreateInfo chain */
4200
4201 static inline void *
vn_decode_VkDeviceGroupDeviceCreateInfo_pnext_temp(struct vn_cs_decoder * dec)4202 vn_decode_VkDeviceGroupDeviceCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
4203 {
4204 /* no known/supported struct */
4205 if (vn_decode_simple_pointer(dec))
4206 vn_cs_decoder_set_fatal(dec);
4207 return NULL;
4208 }
4209
4210 static inline void
vn_decode_VkDeviceGroupDeviceCreateInfo_self_temp(struct vn_cs_decoder * dec,VkDeviceGroupDeviceCreateInfo * val)4211 vn_decode_VkDeviceGroupDeviceCreateInfo_self_temp(struct vn_cs_decoder *dec, VkDeviceGroupDeviceCreateInfo *val)
4212 {
4213 /* skip val->{sType,pNext} */
4214 vn_decode_uint32_t(dec, &val->physicalDeviceCount);
4215 if (vn_peek_array_size(dec)) {
4216 const uint32_t iter_count = vn_decode_array_size(dec, val->physicalDeviceCount);
4217 val->pPhysicalDevices = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pPhysicalDevices) * iter_count);
4218 if (!val->pPhysicalDevices) return;
4219 for (uint32_t i = 0; i < iter_count; i++)
4220 vn_decode_VkPhysicalDevice_lookup(dec, &((VkPhysicalDevice *)val->pPhysicalDevices)[i]);
4221 } else {
4222 vn_decode_array_size(dec, val->physicalDeviceCount);
4223 val->pPhysicalDevices = NULL;
4224 }
4225 }
4226
4227 static inline void
vn_decode_VkDeviceGroupDeviceCreateInfo_temp(struct vn_cs_decoder * dec,VkDeviceGroupDeviceCreateInfo * val)4228 vn_decode_VkDeviceGroupDeviceCreateInfo_temp(struct vn_cs_decoder *dec, VkDeviceGroupDeviceCreateInfo *val)
4229 {
4230 VkStructureType stype;
4231 vn_decode_VkStructureType(dec, &stype);
4232 if (stype != VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO)
4233 vn_cs_decoder_set_fatal(dec);
4234
4235 val->sType = stype;
4236 val->pNext = vn_decode_VkDeviceGroupDeviceCreateInfo_pnext_temp(dec);
4237 vn_decode_VkDeviceGroupDeviceCreateInfo_self_temp(dec, val);
4238 }
4239
4240 static inline void
vn_replace_VkDeviceGroupDeviceCreateInfo_handle_self(VkDeviceGroupDeviceCreateInfo * val)4241 vn_replace_VkDeviceGroupDeviceCreateInfo_handle_self(VkDeviceGroupDeviceCreateInfo *val)
4242 {
4243 /* skip val->sType */
4244 /* skip val->pNext */
4245 /* skip val->physicalDeviceCount */
4246 if (val->pPhysicalDevices) {
4247 for (uint32_t i = 0; i < val->physicalDeviceCount; i++)
4248 vn_replace_VkPhysicalDevice_handle(&((VkPhysicalDevice *)val->pPhysicalDevices)[i]);
4249 }
4250 }
4251
4252 static inline void
vn_replace_VkDeviceGroupDeviceCreateInfo_handle(VkDeviceGroupDeviceCreateInfo * val)4253 vn_replace_VkDeviceGroupDeviceCreateInfo_handle(VkDeviceGroupDeviceCreateInfo *val)
4254 {
4255 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
4256
4257 do {
4258 switch ((int32_t)pnext->sType) {
4259 case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
4260 vn_replace_VkDeviceGroupDeviceCreateInfo_handle_self((VkDeviceGroupDeviceCreateInfo *)pnext);
4261 break;
4262 default:
4263 /* ignore unknown/unsupported struct */
4264 break;
4265 }
4266 pnext = pnext->pNext;
4267 } while (pnext);
4268 }
4269
4270 /* struct VkDeviceCreateInfo chain */
4271
4272 static inline void *
vn_decode_VkDeviceCreateInfo_pnext_temp(struct vn_cs_decoder * dec)4273 vn_decode_VkDeviceCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
4274 {
4275 VkBaseOutStructure *pnext;
4276 VkStructureType stype;
4277
4278 if (!vn_decode_simple_pointer(dec))
4279 return NULL;
4280
4281 vn_decode_VkStructureType(dec, &stype);
4282 switch ((int32_t)stype) {
4283 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
4284 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceFeatures2));
4285 if (pnext) {
4286 pnext->sType = stype;
4287 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4288 vn_decode_VkPhysicalDeviceFeatures2_self_temp(dec, (VkPhysicalDeviceFeatures2 *)pnext);
4289 }
4290 break;
4291 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
4292 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceVariablePointersFeatures));
4293 if (pnext) {
4294 pnext->sType = stype;
4295 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4296 vn_decode_VkPhysicalDeviceVariablePointersFeatures_self_temp(dec, (VkPhysicalDeviceVariablePointersFeatures *)pnext);
4297 }
4298 break;
4299 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
4300 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceMultiviewFeatures));
4301 if (pnext) {
4302 pnext->sType = stype;
4303 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4304 vn_decode_VkPhysicalDeviceMultiviewFeatures_self_temp(dec, (VkPhysicalDeviceMultiviewFeatures *)pnext);
4305 }
4306 break;
4307 case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
4308 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkDeviceGroupDeviceCreateInfo));
4309 if (pnext) {
4310 pnext->sType = stype;
4311 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4312 vn_decode_VkDeviceGroupDeviceCreateInfo_self_temp(dec, (VkDeviceGroupDeviceCreateInfo *)pnext);
4313 }
4314 break;
4315 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
4316 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDevice16BitStorageFeatures));
4317 if (pnext) {
4318 pnext->sType = stype;
4319 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4320 vn_decode_VkPhysicalDevice16BitStorageFeatures_self_temp(dec, (VkPhysicalDevice16BitStorageFeatures *)pnext);
4321 }
4322 break;
4323 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
4324 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures));
4325 if (pnext) {
4326 pnext->sType = stype;
4327 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4328 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_temp(dec, (VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
4329 }
4330 break;
4331 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
4332 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures));
4333 if (pnext) {
4334 pnext->sType = stype;
4335 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4336 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_temp(dec, (VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
4337 }
4338 break;
4339 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
4340 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceProtectedMemoryFeatures));
4341 if (pnext) {
4342 pnext->sType = stype;
4343 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4344 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self_temp(dec, (VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
4345 }
4346 break;
4347 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
4348 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceShaderDrawParametersFeatures));
4349 if (pnext) {
4350 pnext->sType = stype;
4351 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4352 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self_temp(dec, (VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
4353 }
4354 break;
4355 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
4356 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceShaderFloat16Int8Features));
4357 if (pnext) {
4358 pnext->sType = stype;
4359 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4360 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self_temp(dec, (VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
4361 }
4362 break;
4363 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
4364 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceHostQueryResetFeatures));
4365 if (pnext) {
4366 pnext->sType = stype;
4367 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4368 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self_temp(dec, (VkPhysicalDeviceHostQueryResetFeatures *)pnext);
4369 }
4370 break;
4371 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
4372 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceDescriptorIndexingFeatures));
4373 if (pnext) {
4374 pnext->sType = stype;
4375 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4376 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self_temp(dec, (VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
4377 }
4378 break;
4379 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
4380 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceTimelineSemaphoreFeatures));
4381 if (pnext) {
4382 pnext->sType = stype;
4383 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4384 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_temp(dec, (VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
4385 }
4386 break;
4387 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
4388 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDevice8BitStorageFeatures));
4389 if (pnext) {
4390 pnext->sType = stype;
4391 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4392 vn_decode_VkPhysicalDevice8BitStorageFeatures_self_temp(dec, (VkPhysicalDevice8BitStorageFeatures *)pnext);
4393 }
4394 break;
4395 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
4396 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceVulkanMemoryModelFeatures));
4397 if (pnext) {
4398 pnext->sType = stype;
4399 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4400 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_temp(dec, (VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
4401 }
4402 break;
4403 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
4404 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceShaderAtomicInt64Features));
4405 if (pnext) {
4406 pnext->sType = stype;
4407 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4408 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self_temp(dec, (VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
4409 }
4410 break;
4411 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
4412 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceTransformFeedbackFeaturesEXT));
4413 if (pnext) {
4414 pnext->sType = stype;
4415 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4416 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_temp(dec, (VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
4417 }
4418 break;
4419 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
4420 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceScalarBlockLayoutFeatures));
4421 if (pnext) {
4422 pnext->sType = stype;
4423 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4424 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_temp(dec, (VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
4425 }
4426 break;
4427 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
4428 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceUniformBufferStandardLayoutFeatures));
4429 if (pnext) {
4430 pnext->sType = stype;
4431 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4432 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_temp(dec, (VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
4433 }
4434 break;
4435 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
4436 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceBufferDeviceAddressFeatures));
4437 if (pnext) {
4438 pnext->sType = stype;
4439 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4440 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_temp(dec, (VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
4441 }
4442 break;
4443 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
4444 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceImagelessFramebufferFeatures));
4445 if (pnext) {
4446 pnext->sType = stype;
4447 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4448 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self_temp(dec, (VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
4449 }
4450 break;
4451 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
4452 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures));
4453 if (pnext) {
4454 pnext->sType = stype;
4455 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4456 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_temp(dec, (VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
4457 }
4458 break;
4459 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
4460 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceVulkan11Features));
4461 if (pnext) {
4462 pnext->sType = stype;
4463 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4464 vn_decode_VkPhysicalDeviceVulkan11Features_self_temp(dec, (VkPhysicalDeviceVulkan11Features *)pnext);
4465 }
4466 break;
4467 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
4468 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceVulkan12Features));
4469 if (pnext) {
4470 pnext->sType = stype;
4471 pnext->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4472 vn_decode_VkPhysicalDeviceVulkan12Features_self_temp(dec, (VkPhysicalDeviceVulkan12Features *)pnext);
4473 }
4474 break;
4475 default:
4476 /* unexpected struct */
4477 pnext = NULL;
4478 vn_cs_decoder_set_fatal(dec);
4479 break;
4480 }
4481
4482 return pnext;
4483 }
4484
4485 static inline void
vn_decode_VkDeviceCreateInfo_self_temp(struct vn_cs_decoder * dec,VkDeviceCreateInfo * val)4486 vn_decode_VkDeviceCreateInfo_self_temp(struct vn_cs_decoder *dec, VkDeviceCreateInfo *val)
4487 {
4488 /* skip val->{sType,pNext} */
4489 vn_decode_VkFlags(dec, &val->flags);
4490 vn_decode_uint32_t(dec, &val->queueCreateInfoCount);
4491 if (vn_peek_array_size(dec)) {
4492 const uint32_t iter_count = vn_decode_array_size(dec, val->queueCreateInfoCount);
4493 val->pQueueCreateInfos = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pQueueCreateInfos) * iter_count);
4494 if (!val->pQueueCreateInfos) return;
4495 for (uint32_t i = 0; i < iter_count; i++)
4496 vn_decode_VkDeviceQueueCreateInfo_temp(dec, &((VkDeviceQueueCreateInfo *)val->pQueueCreateInfos)[i]);
4497 } else {
4498 vn_decode_array_size(dec, val->queueCreateInfoCount);
4499 val->pQueueCreateInfos = NULL;
4500 }
4501 vn_decode_uint32_t(dec, &val->enabledLayerCount);
4502 if (vn_peek_array_size(dec)) {
4503 const uint32_t iter_count = vn_decode_array_size(dec, val->enabledLayerCount);
4504 val->ppEnabledLayerNames = vn_cs_decoder_alloc_temp(dec, sizeof(*val->ppEnabledLayerNames) * iter_count);
4505 if (!val->ppEnabledLayerNames) return;
4506 for (uint32_t i = 0; i < iter_count; i++) {
4507 const size_t string_size = vn_decode_array_size_unchecked(dec);
4508 ((char **)val->ppEnabledLayerNames)[i] = vn_cs_decoder_alloc_temp(dec, sizeof(*val->ppEnabledLayerNames[i]) * string_size);
4509 if (!val->ppEnabledLayerNames[i]) return;
4510 vn_decode_char_array(dec, ((char **)val->ppEnabledLayerNames)[i], string_size);
4511 }
4512 } else {
4513 vn_decode_array_size(dec, val->enabledLayerCount);
4514 val->ppEnabledLayerNames = NULL;
4515 }
4516 vn_decode_uint32_t(dec, &val->enabledExtensionCount);
4517 if (vn_peek_array_size(dec)) {
4518 const uint32_t iter_count = vn_decode_array_size(dec, val->enabledExtensionCount);
4519 val->ppEnabledExtensionNames = vn_cs_decoder_alloc_temp(dec, sizeof(*val->ppEnabledExtensionNames) * iter_count);
4520 if (!val->ppEnabledExtensionNames) return;
4521 for (uint32_t i = 0; i < iter_count; i++) {
4522 const size_t string_size = vn_decode_array_size_unchecked(dec);
4523 ((char **)val->ppEnabledExtensionNames)[i] = vn_cs_decoder_alloc_temp(dec, sizeof(*val->ppEnabledExtensionNames[i]) * string_size);
4524 if (!val->ppEnabledExtensionNames[i]) return;
4525 vn_decode_char_array(dec, ((char **)val->ppEnabledExtensionNames)[i], string_size);
4526 }
4527 } else {
4528 vn_decode_array_size(dec, val->enabledExtensionCount);
4529 val->ppEnabledExtensionNames = NULL;
4530 }
4531 if (vn_decode_simple_pointer(dec)) {
4532 val->pEnabledFeatures = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pEnabledFeatures));
4533 if (!val->pEnabledFeatures) return;
4534 vn_decode_VkPhysicalDeviceFeatures_temp(dec, (VkPhysicalDeviceFeatures *)val->pEnabledFeatures);
4535 } else {
4536 val->pEnabledFeatures = NULL;
4537 }
4538 }
4539
4540 static inline void
vn_decode_VkDeviceCreateInfo_temp(struct vn_cs_decoder * dec,VkDeviceCreateInfo * val)4541 vn_decode_VkDeviceCreateInfo_temp(struct vn_cs_decoder *dec, VkDeviceCreateInfo *val)
4542 {
4543 VkStructureType stype;
4544 vn_decode_VkStructureType(dec, &stype);
4545 if (stype != VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO)
4546 vn_cs_decoder_set_fatal(dec);
4547
4548 val->sType = stype;
4549 val->pNext = vn_decode_VkDeviceCreateInfo_pnext_temp(dec);
4550 vn_decode_VkDeviceCreateInfo_self_temp(dec, val);
4551 }
4552
4553 static inline void
vn_replace_VkDeviceCreateInfo_handle_self(VkDeviceCreateInfo * val)4554 vn_replace_VkDeviceCreateInfo_handle_self(VkDeviceCreateInfo *val)
4555 {
4556 /* skip val->sType */
4557 /* skip val->pNext */
4558 /* skip val->flags */
4559 /* skip val->queueCreateInfoCount */
4560 if (val->pQueueCreateInfos) {
4561 for (uint32_t i = 0; i < val->queueCreateInfoCount; i++)
4562 vn_replace_VkDeviceQueueCreateInfo_handle(&((VkDeviceQueueCreateInfo *)val->pQueueCreateInfos)[i]);
4563 }
4564 /* skip val->enabledLayerCount */
4565 /* skip val->ppEnabledLayerNames */
4566 /* skip val->enabledExtensionCount */
4567 /* skip val->ppEnabledExtensionNames */
4568 if (val->pEnabledFeatures)
4569 vn_replace_VkPhysicalDeviceFeatures_handle((VkPhysicalDeviceFeatures *)val->pEnabledFeatures);
4570 }
4571
4572 static inline void
vn_replace_VkDeviceCreateInfo_handle(VkDeviceCreateInfo * val)4573 vn_replace_VkDeviceCreateInfo_handle(VkDeviceCreateInfo *val)
4574 {
4575 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
4576
4577 do {
4578 switch ((int32_t)pnext->sType) {
4579 case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
4580 vn_replace_VkDeviceCreateInfo_handle_self((VkDeviceCreateInfo *)pnext);
4581 break;
4582 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
4583 vn_replace_VkPhysicalDeviceFeatures2_handle_self((VkPhysicalDeviceFeatures2 *)pnext);
4584 break;
4585 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
4586 vn_replace_VkPhysicalDeviceVariablePointersFeatures_handle_self((VkPhysicalDeviceVariablePointersFeatures *)pnext);
4587 break;
4588 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
4589 vn_replace_VkPhysicalDeviceMultiviewFeatures_handle_self((VkPhysicalDeviceMultiviewFeatures *)pnext);
4590 break;
4591 case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
4592 vn_replace_VkDeviceGroupDeviceCreateInfo_handle_self((VkDeviceGroupDeviceCreateInfo *)pnext);
4593 break;
4594 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
4595 vn_replace_VkPhysicalDevice16BitStorageFeatures_handle_self((VkPhysicalDevice16BitStorageFeatures *)pnext);
4596 break;
4597 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
4598 vn_replace_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_handle_self((VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
4599 break;
4600 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
4601 vn_replace_VkPhysicalDeviceSamplerYcbcrConversionFeatures_handle_self((VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
4602 break;
4603 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
4604 vn_replace_VkPhysicalDeviceProtectedMemoryFeatures_handle_self((VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
4605 break;
4606 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
4607 vn_replace_VkPhysicalDeviceShaderDrawParametersFeatures_handle_self((VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
4608 break;
4609 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
4610 vn_replace_VkPhysicalDeviceShaderFloat16Int8Features_handle_self((VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
4611 break;
4612 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
4613 vn_replace_VkPhysicalDeviceHostQueryResetFeatures_handle_self((VkPhysicalDeviceHostQueryResetFeatures *)pnext);
4614 break;
4615 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
4616 vn_replace_VkPhysicalDeviceDescriptorIndexingFeatures_handle_self((VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
4617 break;
4618 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
4619 vn_replace_VkPhysicalDeviceTimelineSemaphoreFeatures_handle_self((VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
4620 break;
4621 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
4622 vn_replace_VkPhysicalDevice8BitStorageFeatures_handle_self((VkPhysicalDevice8BitStorageFeatures *)pnext);
4623 break;
4624 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
4625 vn_replace_VkPhysicalDeviceVulkanMemoryModelFeatures_handle_self((VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
4626 break;
4627 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
4628 vn_replace_VkPhysicalDeviceShaderAtomicInt64Features_handle_self((VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
4629 break;
4630 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
4631 vn_replace_VkPhysicalDeviceTransformFeedbackFeaturesEXT_handle_self((VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
4632 break;
4633 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
4634 vn_replace_VkPhysicalDeviceScalarBlockLayoutFeatures_handle_self((VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
4635 break;
4636 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
4637 vn_replace_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_handle_self((VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
4638 break;
4639 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
4640 vn_replace_VkPhysicalDeviceBufferDeviceAddressFeatures_handle_self((VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
4641 break;
4642 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
4643 vn_replace_VkPhysicalDeviceImagelessFramebufferFeatures_handle_self((VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
4644 break;
4645 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
4646 vn_replace_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_handle_self((VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
4647 break;
4648 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
4649 vn_replace_VkPhysicalDeviceVulkan11Features_handle_self((VkPhysicalDeviceVulkan11Features *)pnext);
4650 break;
4651 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
4652 vn_replace_VkPhysicalDeviceVulkan12Features_handle_self((VkPhysicalDeviceVulkan12Features *)pnext);
4653 break;
4654 default:
4655 /* ignore unknown/unsupported struct */
4656 break;
4657 }
4658 pnext = pnext->pNext;
4659 } while (pnext);
4660 }
4661
4662 /* struct VkConformanceVersion */
4663
4664 static inline void
vn_encode_VkConformanceVersion(struct vn_cs_encoder * enc,const VkConformanceVersion * val)4665 vn_encode_VkConformanceVersion(struct vn_cs_encoder *enc, const VkConformanceVersion *val)
4666 {
4667 vn_encode_uint8_t(enc, &val->major);
4668 vn_encode_uint8_t(enc, &val->minor);
4669 vn_encode_uint8_t(enc, &val->subminor);
4670 vn_encode_uint8_t(enc, &val->patch);
4671 }
4672
4673 static inline void
vn_decode_VkConformanceVersion_partial_temp(struct vn_cs_decoder * dec,VkConformanceVersion * val)4674 vn_decode_VkConformanceVersion_partial_temp(struct vn_cs_decoder *dec, VkConformanceVersion *val)
4675 {
4676 /* skip val->major */
4677 /* skip val->minor */
4678 /* skip val->subminor */
4679 /* skip val->patch */
4680 }
4681
4682 /* struct VkPhysicalDeviceDriverProperties chain */
4683
4684 static inline void
vn_encode_VkPhysicalDeviceDriverProperties_pnext(struct vn_cs_encoder * enc,const void * val)4685 vn_encode_VkPhysicalDeviceDriverProperties_pnext(struct vn_cs_encoder *enc, const void *val)
4686 {
4687 /* no known/supported struct */
4688 vn_encode_simple_pointer(enc, NULL);
4689 }
4690
4691 static inline void
vn_encode_VkPhysicalDeviceDriverProperties_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceDriverProperties * val)4692 vn_encode_VkPhysicalDeviceDriverProperties_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceDriverProperties *val)
4693 {
4694 /* skip val->{sType,pNext} */
4695 vn_encode_VkDriverId(enc, &val->driverID);
4696 vn_encode_array_size(enc, VK_MAX_DRIVER_NAME_SIZE);
4697 vn_encode_char_array(enc, val->driverName, VK_MAX_DRIVER_NAME_SIZE);
4698 vn_encode_array_size(enc, VK_MAX_DRIVER_INFO_SIZE);
4699 vn_encode_char_array(enc, val->driverInfo, VK_MAX_DRIVER_INFO_SIZE);
4700 vn_encode_VkConformanceVersion(enc, &val->conformanceVersion);
4701 }
4702
4703 static inline void
vn_encode_VkPhysicalDeviceDriverProperties(struct vn_cs_encoder * enc,const VkPhysicalDeviceDriverProperties * val)4704 vn_encode_VkPhysicalDeviceDriverProperties(struct vn_cs_encoder *enc, const VkPhysicalDeviceDriverProperties *val)
4705 {
4706 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
4707 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES });
4708 vn_encode_VkPhysicalDeviceDriverProperties_pnext(enc, val->pNext);
4709 vn_encode_VkPhysicalDeviceDriverProperties_self(enc, val);
4710 }
4711
4712 static inline void *
vn_decode_VkPhysicalDeviceDriverProperties_pnext_partial_temp(struct vn_cs_decoder * dec)4713 vn_decode_VkPhysicalDeviceDriverProperties_pnext_partial_temp(struct vn_cs_decoder *dec)
4714 {
4715 /* no known/supported struct */
4716 if (vn_decode_simple_pointer(dec))
4717 vn_cs_decoder_set_fatal(dec);
4718 return NULL;
4719 }
4720
4721 static inline void
vn_decode_VkPhysicalDeviceDriverProperties_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceDriverProperties * val)4722 vn_decode_VkPhysicalDeviceDriverProperties_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceDriverProperties *val)
4723 {
4724 /* skip val->{sType,pNext} */
4725 /* skip val->driverID */
4726 /* skip val->driverName */
4727 /* skip val->driverInfo */
4728 vn_decode_VkConformanceVersion_partial_temp(dec, &val->conformanceVersion);
4729 }
4730
4731 static inline void
vn_decode_VkPhysicalDeviceDriverProperties_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceDriverProperties * val)4732 vn_decode_VkPhysicalDeviceDriverProperties_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceDriverProperties *val)
4733 {
4734 VkStructureType stype;
4735 vn_decode_VkStructureType(dec, &stype);
4736 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES)
4737 vn_cs_decoder_set_fatal(dec);
4738
4739 val->sType = stype;
4740 val->pNext = vn_decode_VkPhysicalDeviceDriverProperties_pnext_partial_temp(dec);
4741 vn_decode_VkPhysicalDeviceDriverProperties_self_partial_temp(dec, val);
4742 }
4743
4744 /* struct VkPhysicalDeviceIDProperties chain */
4745
4746 static inline void
vn_encode_VkPhysicalDeviceIDProperties_pnext(struct vn_cs_encoder * enc,const void * val)4747 vn_encode_VkPhysicalDeviceIDProperties_pnext(struct vn_cs_encoder *enc, const void *val)
4748 {
4749 /* no known/supported struct */
4750 vn_encode_simple_pointer(enc, NULL);
4751 }
4752
4753 static inline void
vn_encode_VkPhysicalDeviceIDProperties_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceIDProperties * val)4754 vn_encode_VkPhysicalDeviceIDProperties_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceIDProperties *val)
4755 {
4756 /* skip val->{sType,pNext} */
4757 vn_encode_array_size(enc, VK_UUID_SIZE);
4758 vn_encode_uint8_t_array(enc, val->deviceUUID, VK_UUID_SIZE);
4759 vn_encode_array_size(enc, VK_UUID_SIZE);
4760 vn_encode_uint8_t_array(enc, val->driverUUID, VK_UUID_SIZE);
4761 vn_encode_array_size(enc, VK_LUID_SIZE);
4762 vn_encode_uint8_t_array(enc, val->deviceLUID, VK_LUID_SIZE);
4763 vn_encode_uint32_t(enc, &val->deviceNodeMask);
4764 vn_encode_VkBool32(enc, &val->deviceLUIDValid);
4765 }
4766
4767 static inline void
vn_encode_VkPhysicalDeviceIDProperties(struct vn_cs_encoder * enc,const VkPhysicalDeviceIDProperties * val)4768 vn_encode_VkPhysicalDeviceIDProperties(struct vn_cs_encoder *enc, const VkPhysicalDeviceIDProperties *val)
4769 {
4770 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
4771 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES });
4772 vn_encode_VkPhysicalDeviceIDProperties_pnext(enc, val->pNext);
4773 vn_encode_VkPhysicalDeviceIDProperties_self(enc, val);
4774 }
4775
4776 static inline void *
vn_decode_VkPhysicalDeviceIDProperties_pnext_partial_temp(struct vn_cs_decoder * dec)4777 vn_decode_VkPhysicalDeviceIDProperties_pnext_partial_temp(struct vn_cs_decoder *dec)
4778 {
4779 /* no known/supported struct */
4780 if (vn_decode_simple_pointer(dec))
4781 vn_cs_decoder_set_fatal(dec);
4782 return NULL;
4783 }
4784
4785 static inline void
vn_decode_VkPhysicalDeviceIDProperties_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceIDProperties * val)4786 vn_decode_VkPhysicalDeviceIDProperties_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceIDProperties *val)
4787 {
4788 /* skip val->{sType,pNext} */
4789 /* skip val->deviceUUID */
4790 /* skip val->driverUUID */
4791 /* skip val->deviceLUID */
4792 /* skip val->deviceNodeMask */
4793 /* skip val->deviceLUIDValid */
4794 }
4795
4796 static inline void
vn_decode_VkPhysicalDeviceIDProperties_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceIDProperties * val)4797 vn_decode_VkPhysicalDeviceIDProperties_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceIDProperties *val)
4798 {
4799 VkStructureType stype;
4800 vn_decode_VkStructureType(dec, &stype);
4801 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES)
4802 vn_cs_decoder_set_fatal(dec);
4803
4804 val->sType = stype;
4805 val->pNext = vn_decode_VkPhysicalDeviceIDProperties_pnext_partial_temp(dec);
4806 vn_decode_VkPhysicalDeviceIDProperties_self_partial_temp(dec, val);
4807 }
4808
4809 /* struct VkPhysicalDeviceMultiviewProperties chain */
4810
4811 static inline void
vn_encode_VkPhysicalDeviceMultiviewProperties_pnext(struct vn_cs_encoder * enc,const void * val)4812 vn_encode_VkPhysicalDeviceMultiviewProperties_pnext(struct vn_cs_encoder *enc, const void *val)
4813 {
4814 /* no known/supported struct */
4815 vn_encode_simple_pointer(enc, NULL);
4816 }
4817
4818 static inline void
vn_encode_VkPhysicalDeviceMultiviewProperties_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewProperties * val)4819 vn_encode_VkPhysicalDeviceMultiviewProperties_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewProperties *val)
4820 {
4821 /* skip val->{sType,pNext} */
4822 vn_encode_uint32_t(enc, &val->maxMultiviewViewCount);
4823 vn_encode_uint32_t(enc, &val->maxMultiviewInstanceIndex);
4824 }
4825
4826 static inline void
vn_encode_VkPhysicalDeviceMultiviewProperties(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewProperties * val)4827 vn_encode_VkPhysicalDeviceMultiviewProperties(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewProperties *val)
4828 {
4829 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
4830 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES });
4831 vn_encode_VkPhysicalDeviceMultiviewProperties_pnext(enc, val->pNext);
4832 vn_encode_VkPhysicalDeviceMultiviewProperties_self(enc, val);
4833 }
4834
4835 static inline void *
vn_decode_VkPhysicalDeviceMultiviewProperties_pnext_partial_temp(struct vn_cs_decoder * dec)4836 vn_decode_VkPhysicalDeviceMultiviewProperties_pnext_partial_temp(struct vn_cs_decoder *dec)
4837 {
4838 /* no known/supported struct */
4839 if (vn_decode_simple_pointer(dec))
4840 vn_cs_decoder_set_fatal(dec);
4841 return NULL;
4842 }
4843
4844 static inline void
vn_decode_VkPhysicalDeviceMultiviewProperties_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewProperties * val)4845 vn_decode_VkPhysicalDeviceMultiviewProperties_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewProperties *val)
4846 {
4847 /* skip val->{sType,pNext} */
4848 /* skip val->maxMultiviewViewCount */
4849 /* skip val->maxMultiviewInstanceIndex */
4850 }
4851
4852 static inline void
vn_decode_VkPhysicalDeviceMultiviewProperties_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewProperties * val)4853 vn_decode_VkPhysicalDeviceMultiviewProperties_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewProperties *val)
4854 {
4855 VkStructureType stype;
4856 vn_decode_VkStructureType(dec, &stype);
4857 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES)
4858 vn_cs_decoder_set_fatal(dec);
4859
4860 val->sType = stype;
4861 val->pNext = vn_decode_VkPhysicalDeviceMultiviewProperties_pnext_partial_temp(dec);
4862 vn_decode_VkPhysicalDeviceMultiviewProperties_self_partial_temp(dec, val);
4863 }
4864
4865 /* struct VkPhysicalDeviceSubgroupProperties chain */
4866
4867 static inline void
vn_encode_VkPhysicalDeviceSubgroupProperties_pnext(struct vn_cs_encoder * enc,const void * val)4868 vn_encode_VkPhysicalDeviceSubgroupProperties_pnext(struct vn_cs_encoder *enc, const void *val)
4869 {
4870 /* no known/supported struct */
4871 vn_encode_simple_pointer(enc, NULL);
4872 }
4873
4874 static inline void
vn_encode_VkPhysicalDeviceSubgroupProperties_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupProperties * val)4875 vn_encode_VkPhysicalDeviceSubgroupProperties_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupProperties *val)
4876 {
4877 /* skip val->{sType,pNext} */
4878 vn_encode_uint32_t(enc, &val->subgroupSize);
4879 vn_encode_VkFlags(enc, &val->supportedStages);
4880 vn_encode_VkFlags(enc, &val->supportedOperations);
4881 vn_encode_VkBool32(enc, &val->quadOperationsInAllStages);
4882 }
4883
4884 static inline void
vn_encode_VkPhysicalDeviceSubgroupProperties(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupProperties * val)4885 vn_encode_VkPhysicalDeviceSubgroupProperties(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupProperties *val)
4886 {
4887 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
4888 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES });
4889 vn_encode_VkPhysicalDeviceSubgroupProperties_pnext(enc, val->pNext);
4890 vn_encode_VkPhysicalDeviceSubgroupProperties_self(enc, val);
4891 }
4892
4893 static inline void *
vn_decode_VkPhysicalDeviceSubgroupProperties_pnext_partial_temp(struct vn_cs_decoder * dec)4894 vn_decode_VkPhysicalDeviceSubgroupProperties_pnext_partial_temp(struct vn_cs_decoder *dec)
4895 {
4896 /* no known/supported struct */
4897 if (vn_decode_simple_pointer(dec))
4898 vn_cs_decoder_set_fatal(dec);
4899 return NULL;
4900 }
4901
4902 static inline void
vn_decode_VkPhysicalDeviceSubgroupProperties_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceSubgroupProperties * val)4903 vn_decode_VkPhysicalDeviceSubgroupProperties_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupProperties *val)
4904 {
4905 /* skip val->{sType,pNext} */
4906 /* skip val->subgroupSize */
4907 /* skip val->supportedStages */
4908 /* skip val->supportedOperations */
4909 /* skip val->quadOperationsInAllStages */
4910 }
4911
4912 static inline void
vn_decode_VkPhysicalDeviceSubgroupProperties_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceSubgroupProperties * val)4913 vn_decode_VkPhysicalDeviceSubgroupProperties_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupProperties *val)
4914 {
4915 VkStructureType stype;
4916 vn_decode_VkStructureType(dec, &stype);
4917 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES)
4918 vn_cs_decoder_set_fatal(dec);
4919
4920 val->sType = stype;
4921 val->pNext = vn_decode_VkPhysicalDeviceSubgroupProperties_pnext_partial_temp(dec);
4922 vn_decode_VkPhysicalDeviceSubgroupProperties_self_partial_temp(dec, val);
4923 }
4924
4925 /* struct VkPhysicalDevicePointClippingProperties chain */
4926
4927 static inline void
vn_encode_VkPhysicalDevicePointClippingProperties_pnext(struct vn_cs_encoder * enc,const void * val)4928 vn_encode_VkPhysicalDevicePointClippingProperties_pnext(struct vn_cs_encoder *enc, const void *val)
4929 {
4930 /* no known/supported struct */
4931 vn_encode_simple_pointer(enc, NULL);
4932 }
4933
4934 static inline void
vn_encode_VkPhysicalDevicePointClippingProperties_self(struct vn_cs_encoder * enc,const VkPhysicalDevicePointClippingProperties * val)4935 vn_encode_VkPhysicalDevicePointClippingProperties_self(struct vn_cs_encoder *enc, const VkPhysicalDevicePointClippingProperties *val)
4936 {
4937 /* skip val->{sType,pNext} */
4938 vn_encode_VkPointClippingBehavior(enc, &val->pointClippingBehavior);
4939 }
4940
4941 static inline void
vn_encode_VkPhysicalDevicePointClippingProperties(struct vn_cs_encoder * enc,const VkPhysicalDevicePointClippingProperties * val)4942 vn_encode_VkPhysicalDevicePointClippingProperties(struct vn_cs_encoder *enc, const VkPhysicalDevicePointClippingProperties *val)
4943 {
4944 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
4945 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES });
4946 vn_encode_VkPhysicalDevicePointClippingProperties_pnext(enc, val->pNext);
4947 vn_encode_VkPhysicalDevicePointClippingProperties_self(enc, val);
4948 }
4949
4950 static inline void *
vn_decode_VkPhysicalDevicePointClippingProperties_pnext_partial_temp(struct vn_cs_decoder * dec)4951 vn_decode_VkPhysicalDevicePointClippingProperties_pnext_partial_temp(struct vn_cs_decoder *dec)
4952 {
4953 /* no known/supported struct */
4954 if (vn_decode_simple_pointer(dec))
4955 vn_cs_decoder_set_fatal(dec);
4956 return NULL;
4957 }
4958
4959 static inline void
vn_decode_VkPhysicalDevicePointClippingProperties_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDevicePointClippingProperties * val)4960 vn_decode_VkPhysicalDevicePointClippingProperties_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDevicePointClippingProperties *val)
4961 {
4962 /* skip val->{sType,pNext} */
4963 /* skip val->pointClippingBehavior */
4964 }
4965
4966 static inline void
vn_decode_VkPhysicalDevicePointClippingProperties_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDevicePointClippingProperties * val)4967 vn_decode_VkPhysicalDevicePointClippingProperties_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDevicePointClippingProperties *val)
4968 {
4969 VkStructureType stype;
4970 vn_decode_VkStructureType(dec, &stype);
4971 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES)
4972 vn_cs_decoder_set_fatal(dec);
4973
4974 val->sType = stype;
4975 val->pNext = vn_decode_VkPhysicalDevicePointClippingProperties_pnext_partial_temp(dec);
4976 vn_decode_VkPhysicalDevicePointClippingProperties_self_partial_temp(dec, val);
4977 }
4978
4979 /* struct VkPhysicalDeviceProtectedMemoryProperties chain */
4980
4981 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext(struct vn_cs_encoder * enc,const void * val)4982 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext(struct vn_cs_encoder *enc, const void *val)
4983 {
4984 /* no known/supported struct */
4985 vn_encode_simple_pointer(enc, NULL);
4986 }
4987
4988 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryProperties * val)4989 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryProperties *val)
4990 {
4991 /* skip val->{sType,pNext} */
4992 vn_encode_VkBool32(enc, &val->protectedNoFault);
4993 }
4994
4995 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryProperties(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryProperties * val)4996 vn_encode_VkPhysicalDeviceProtectedMemoryProperties(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryProperties *val)
4997 {
4998 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
4999 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES });
5000 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext(enc, val->pNext);
5001 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self(enc, val);
5002 }
5003
5004 static inline void *
vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial_temp(struct vn_cs_decoder * dec)5005 vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial_temp(struct vn_cs_decoder *dec)
5006 {
5007 /* no known/supported struct */
5008 if (vn_decode_simple_pointer(dec))
5009 vn_cs_decoder_set_fatal(dec);
5010 return NULL;
5011 }
5012
5013 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryProperties * val)5014 vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryProperties *val)
5015 {
5016 /* skip val->{sType,pNext} */
5017 /* skip val->protectedNoFault */
5018 }
5019
5020 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryProperties_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryProperties * val)5021 vn_decode_VkPhysicalDeviceProtectedMemoryProperties_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryProperties *val)
5022 {
5023 VkStructureType stype;
5024 vn_decode_VkStructureType(dec, &stype);
5025 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES)
5026 vn_cs_decoder_set_fatal(dec);
5027
5028 val->sType = stype;
5029 val->pNext = vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial_temp(dec);
5030 vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self_partial_temp(dec, val);
5031 }
5032
5033 /* struct VkPhysicalDeviceSamplerFilterMinmaxProperties chain */
5034
5035 static inline void
vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(struct vn_cs_encoder * enc,const void * val)5036 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(struct vn_cs_encoder *enc, const void *val)
5037 {
5038 /* no known/supported struct */
5039 vn_encode_simple_pointer(enc, NULL);
5040 }
5041
5042 static inline void
vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)5043 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
5044 {
5045 /* skip val->{sType,pNext} */
5046 vn_encode_VkBool32(enc, &val->filterMinmaxSingleComponentFormats);
5047 vn_encode_VkBool32(enc, &val->filterMinmaxImageComponentMapping);
5048 }
5049
5050 static inline void
vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)5051 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
5052 {
5053 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
5054 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES });
5055 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(enc, val->pNext);
5056 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(enc, val);
5057 }
5058
5059 static inline void *
vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial_temp(struct vn_cs_decoder * dec)5060 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial_temp(struct vn_cs_decoder *dec)
5061 {
5062 /* no known/supported struct */
5063 if (vn_decode_simple_pointer(dec))
5064 vn_cs_decoder_set_fatal(dec);
5065 return NULL;
5066 }
5067
5068 static inline void
vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerFilterMinmaxProperties * val)5069 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
5070 {
5071 /* skip val->{sType,pNext} */
5072 /* skip val->filterMinmaxSingleComponentFormats */
5073 /* skip val->filterMinmaxImageComponentMapping */
5074 }
5075
5076 static inline void
vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerFilterMinmaxProperties * val)5077 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
5078 {
5079 VkStructureType stype;
5080 vn_decode_VkStructureType(dec, &stype);
5081 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES)
5082 vn_cs_decoder_set_fatal(dec);
5083
5084 val->sType = stype;
5085 val->pNext = vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial_temp(dec);
5086 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial_temp(dec, val);
5087 }
5088
5089 /* struct VkPhysicalDeviceMaintenance3Properties chain */
5090
5091 static inline void
vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext(struct vn_cs_encoder * enc,const void * val)5092 vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext(struct vn_cs_encoder *enc, const void *val)
5093 {
5094 /* no known/supported struct */
5095 vn_encode_simple_pointer(enc, NULL);
5096 }
5097
5098 static inline void
vn_encode_VkPhysicalDeviceMaintenance3Properties_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance3Properties * val)5099 vn_encode_VkPhysicalDeviceMaintenance3Properties_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance3Properties *val)
5100 {
5101 /* skip val->{sType,pNext} */
5102 vn_encode_uint32_t(enc, &val->maxPerSetDescriptors);
5103 vn_encode_VkDeviceSize(enc, &val->maxMemoryAllocationSize);
5104 }
5105
5106 static inline void
vn_encode_VkPhysicalDeviceMaintenance3Properties(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance3Properties * val)5107 vn_encode_VkPhysicalDeviceMaintenance3Properties(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance3Properties *val)
5108 {
5109 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
5110 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES });
5111 vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext(enc, val->pNext);
5112 vn_encode_VkPhysicalDeviceMaintenance3Properties_self(enc, val);
5113 }
5114
5115 static inline void *
vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext_partial_temp(struct vn_cs_decoder * dec)5116 vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext_partial_temp(struct vn_cs_decoder *dec)
5117 {
5118 /* no known/supported struct */
5119 if (vn_decode_simple_pointer(dec))
5120 vn_cs_decoder_set_fatal(dec);
5121 return NULL;
5122 }
5123
5124 static inline void
vn_decode_VkPhysicalDeviceMaintenance3Properties_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance3Properties * val)5125 vn_decode_VkPhysicalDeviceMaintenance3Properties_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance3Properties *val)
5126 {
5127 /* skip val->{sType,pNext} */
5128 /* skip val->maxPerSetDescriptors */
5129 /* skip val->maxMemoryAllocationSize */
5130 }
5131
5132 static inline void
vn_decode_VkPhysicalDeviceMaintenance3Properties_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance3Properties * val)5133 vn_decode_VkPhysicalDeviceMaintenance3Properties_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance3Properties *val)
5134 {
5135 VkStructureType stype;
5136 vn_decode_VkStructureType(dec, &stype);
5137 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES)
5138 vn_cs_decoder_set_fatal(dec);
5139
5140 val->sType = stype;
5141 val->pNext = vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext_partial_temp(dec);
5142 vn_decode_VkPhysicalDeviceMaintenance3Properties_self_partial_temp(dec, val);
5143 }
5144
5145 /* struct VkPhysicalDeviceFloatControlsProperties chain */
5146
5147 static inline void
vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext(struct vn_cs_encoder * enc,const void * val)5148 vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext(struct vn_cs_encoder *enc, const void *val)
5149 {
5150 /* no known/supported struct */
5151 vn_encode_simple_pointer(enc, NULL);
5152 }
5153
5154 static inline void
vn_encode_VkPhysicalDeviceFloatControlsProperties_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceFloatControlsProperties * val)5155 vn_encode_VkPhysicalDeviceFloatControlsProperties_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceFloatControlsProperties *val)
5156 {
5157 /* skip val->{sType,pNext} */
5158 vn_encode_VkShaderFloatControlsIndependence(enc, &val->denormBehaviorIndependence);
5159 vn_encode_VkShaderFloatControlsIndependence(enc, &val->roundingModeIndependence);
5160 vn_encode_VkBool32(enc, &val->shaderSignedZeroInfNanPreserveFloat16);
5161 vn_encode_VkBool32(enc, &val->shaderSignedZeroInfNanPreserveFloat32);
5162 vn_encode_VkBool32(enc, &val->shaderSignedZeroInfNanPreserveFloat64);
5163 vn_encode_VkBool32(enc, &val->shaderDenormPreserveFloat16);
5164 vn_encode_VkBool32(enc, &val->shaderDenormPreserveFloat32);
5165 vn_encode_VkBool32(enc, &val->shaderDenormPreserveFloat64);
5166 vn_encode_VkBool32(enc, &val->shaderDenormFlushToZeroFloat16);
5167 vn_encode_VkBool32(enc, &val->shaderDenormFlushToZeroFloat32);
5168 vn_encode_VkBool32(enc, &val->shaderDenormFlushToZeroFloat64);
5169 vn_encode_VkBool32(enc, &val->shaderRoundingModeRTEFloat16);
5170 vn_encode_VkBool32(enc, &val->shaderRoundingModeRTEFloat32);
5171 vn_encode_VkBool32(enc, &val->shaderRoundingModeRTEFloat64);
5172 vn_encode_VkBool32(enc, &val->shaderRoundingModeRTZFloat16);
5173 vn_encode_VkBool32(enc, &val->shaderRoundingModeRTZFloat32);
5174 vn_encode_VkBool32(enc, &val->shaderRoundingModeRTZFloat64);
5175 }
5176
5177 static inline void
vn_encode_VkPhysicalDeviceFloatControlsProperties(struct vn_cs_encoder * enc,const VkPhysicalDeviceFloatControlsProperties * val)5178 vn_encode_VkPhysicalDeviceFloatControlsProperties(struct vn_cs_encoder *enc, const VkPhysicalDeviceFloatControlsProperties *val)
5179 {
5180 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
5181 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES });
5182 vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext(enc, val->pNext);
5183 vn_encode_VkPhysicalDeviceFloatControlsProperties_self(enc, val);
5184 }
5185
5186 static inline void *
vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext_partial_temp(struct vn_cs_decoder * dec)5187 vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext_partial_temp(struct vn_cs_decoder *dec)
5188 {
5189 /* no known/supported struct */
5190 if (vn_decode_simple_pointer(dec))
5191 vn_cs_decoder_set_fatal(dec);
5192 return NULL;
5193 }
5194
5195 static inline void
vn_decode_VkPhysicalDeviceFloatControlsProperties_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceFloatControlsProperties * val)5196 vn_decode_VkPhysicalDeviceFloatControlsProperties_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceFloatControlsProperties *val)
5197 {
5198 /* skip val->{sType,pNext} */
5199 /* skip val->denormBehaviorIndependence */
5200 /* skip val->roundingModeIndependence */
5201 /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
5202 /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
5203 /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
5204 /* skip val->shaderDenormPreserveFloat16 */
5205 /* skip val->shaderDenormPreserveFloat32 */
5206 /* skip val->shaderDenormPreserveFloat64 */
5207 /* skip val->shaderDenormFlushToZeroFloat16 */
5208 /* skip val->shaderDenormFlushToZeroFloat32 */
5209 /* skip val->shaderDenormFlushToZeroFloat64 */
5210 /* skip val->shaderRoundingModeRTEFloat16 */
5211 /* skip val->shaderRoundingModeRTEFloat32 */
5212 /* skip val->shaderRoundingModeRTEFloat64 */
5213 /* skip val->shaderRoundingModeRTZFloat16 */
5214 /* skip val->shaderRoundingModeRTZFloat32 */
5215 /* skip val->shaderRoundingModeRTZFloat64 */
5216 }
5217
5218 static inline void
vn_decode_VkPhysicalDeviceFloatControlsProperties_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceFloatControlsProperties * val)5219 vn_decode_VkPhysicalDeviceFloatControlsProperties_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceFloatControlsProperties *val)
5220 {
5221 VkStructureType stype;
5222 vn_decode_VkStructureType(dec, &stype);
5223 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES)
5224 vn_cs_decoder_set_fatal(dec);
5225
5226 val->sType = stype;
5227 val->pNext = vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext_partial_temp(dec);
5228 vn_decode_VkPhysicalDeviceFloatControlsProperties_self_partial_temp(dec, val);
5229 }
5230
5231 /* struct VkPhysicalDeviceDescriptorIndexingProperties chain */
5232
5233 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(struct vn_cs_encoder * enc,const void * val)5234 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(struct vn_cs_encoder *enc, const void *val)
5235 {
5236 /* no known/supported struct */
5237 vn_encode_simple_pointer(enc, NULL);
5238 }
5239
5240 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingProperties * val)5241 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingProperties *val)
5242 {
5243 /* skip val->{sType,pNext} */
5244 vn_encode_uint32_t(enc, &val->maxUpdateAfterBindDescriptorsInAllPools);
5245 vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayNonUniformIndexingNative);
5246 vn_encode_VkBool32(enc, &val->shaderSampledImageArrayNonUniformIndexingNative);
5247 vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayNonUniformIndexingNative);
5248 vn_encode_VkBool32(enc, &val->shaderStorageImageArrayNonUniformIndexingNative);
5249 vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayNonUniformIndexingNative);
5250 vn_encode_VkBool32(enc, &val->robustBufferAccessUpdateAfterBind);
5251 vn_encode_VkBool32(enc, &val->quadDivergentImplicitLod);
5252 vn_encode_uint32_t(enc, &val->maxPerStageDescriptorUpdateAfterBindSamplers);
5253 vn_encode_uint32_t(enc, &val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
5254 vn_encode_uint32_t(enc, &val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
5255 vn_encode_uint32_t(enc, &val->maxPerStageDescriptorUpdateAfterBindSampledImages);
5256 vn_encode_uint32_t(enc, &val->maxPerStageDescriptorUpdateAfterBindStorageImages);
5257 vn_encode_uint32_t(enc, &val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
5258 vn_encode_uint32_t(enc, &val->maxPerStageUpdateAfterBindResources);
5259 vn_encode_uint32_t(enc, &val->maxDescriptorSetUpdateAfterBindSamplers);
5260 vn_encode_uint32_t(enc, &val->maxDescriptorSetUpdateAfterBindUniformBuffers);
5261 vn_encode_uint32_t(enc, &val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
5262 vn_encode_uint32_t(enc, &val->maxDescriptorSetUpdateAfterBindStorageBuffers);
5263 vn_encode_uint32_t(enc, &val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
5264 vn_encode_uint32_t(enc, &val->maxDescriptorSetUpdateAfterBindSampledImages);
5265 vn_encode_uint32_t(enc, &val->maxDescriptorSetUpdateAfterBindStorageImages);
5266 vn_encode_uint32_t(enc, &val->maxDescriptorSetUpdateAfterBindInputAttachments);
5267 }
5268
5269 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingProperties(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingProperties * val)5270 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingProperties *val)
5271 {
5272 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
5273 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES });
5274 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(enc, val->pNext);
5275 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self(enc, val);
5276 }
5277
5278 static inline void *
vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial_temp(struct vn_cs_decoder * dec)5279 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial_temp(struct vn_cs_decoder *dec)
5280 {
5281 /* no known/supported struct */
5282 if (vn_decode_simple_pointer(dec))
5283 vn_cs_decoder_set_fatal(dec);
5284 return NULL;
5285 }
5286
5287 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingProperties * val)5288 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingProperties *val)
5289 {
5290 /* skip val->{sType,pNext} */
5291 /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
5292 /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
5293 /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
5294 /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
5295 /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
5296 /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
5297 /* skip val->robustBufferAccessUpdateAfterBind */
5298 /* skip val->quadDivergentImplicitLod */
5299 /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
5300 /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
5301 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
5302 /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
5303 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
5304 /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
5305 /* skip val->maxPerStageUpdateAfterBindResources */
5306 /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
5307 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
5308 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
5309 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
5310 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
5311 /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
5312 /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
5313 /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
5314 }
5315
5316 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingProperties * val)5317 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingProperties *val)
5318 {
5319 VkStructureType stype;
5320 vn_decode_VkStructureType(dec, &stype);
5321 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES)
5322 vn_cs_decoder_set_fatal(dec);
5323
5324 val->sType = stype;
5325 val->pNext = vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial_temp(dec);
5326 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial_temp(dec, val);
5327 }
5328
5329 /* struct VkPhysicalDeviceTimelineSemaphoreProperties chain */
5330
5331 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(struct vn_cs_encoder * enc,const void * val)5332 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(struct vn_cs_encoder *enc, const void *val)
5333 {
5334 /* no known/supported struct */
5335 vn_encode_simple_pointer(enc, NULL);
5336 }
5337
5338 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreProperties * val)5339 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreProperties *val)
5340 {
5341 /* skip val->{sType,pNext} */
5342 vn_encode_uint64_t(enc, &val->maxTimelineSemaphoreValueDifference);
5343 }
5344
5345 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreProperties * val)5346 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreProperties *val)
5347 {
5348 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
5349 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES });
5350 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(enc, val->pNext);
5351 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self(enc, val);
5352 }
5353
5354 static inline void *
vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial_temp(struct vn_cs_decoder * dec)5355 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial_temp(struct vn_cs_decoder *dec)
5356 {
5357 /* no known/supported struct */
5358 if (vn_decode_simple_pointer(dec))
5359 vn_cs_decoder_set_fatal(dec);
5360 return NULL;
5361 }
5362
5363 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreProperties * val)5364 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreProperties *val)
5365 {
5366 /* skip val->{sType,pNext} */
5367 /* skip val->maxTimelineSemaphoreValueDifference */
5368 }
5369
5370 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreProperties * val)5371 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreProperties *val)
5372 {
5373 VkStructureType stype;
5374 vn_decode_VkStructureType(dec, &stype);
5375 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES)
5376 vn_cs_decoder_set_fatal(dec);
5377
5378 val->sType = stype;
5379 val->pNext = vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial_temp(dec);
5380 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial_temp(dec, val);
5381 }
5382
5383 /* struct VkPhysicalDeviceDepthStencilResolveProperties chain */
5384
5385 static inline void
vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(struct vn_cs_encoder * enc,const void * val)5386 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(struct vn_cs_encoder *enc, const void *val)
5387 {
5388 /* no known/supported struct */
5389 vn_encode_simple_pointer(enc, NULL);
5390 }
5391
5392 static inline void
vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthStencilResolveProperties * val)5393 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthStencilResolveProperties *val)
5394 {
5395 /* skip val->{sType,pNext} */
5396 vn_encode_VkFlags(enc, &val->supportedDepthResolveModes);
5397 vn_encode_VkFlags(enc, &val->supportedStencilResolveModes);
5398 vn_encode_VkBool32(enc, &val->independentResolveNone);
5399 vn_encode_VkBool32(enc, &val->independentResolve);
5400 }
5401
5402 static inline void
vn_encode_VkPhysicalDeviceDepthStencilResolveProperties(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthStencilResolveProperties * val)5403 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthStencilResolveProperties *val)
5404 {
5405 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
5406 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES });
5407 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(enc, val->pNext);
5408 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self(enc, val);
5409 }
5410
5411 static inline void *
vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial_temp(struct vn_cs_decoder * dec)5412 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial_temp(struct vn_cs_decoder *dec)
5413 {
5414 /* no known/supported struct */
5415 if (vn_decode_simple_pointer(dec))
5416 vn_cs_decoder_set_fatal(dec);
5417 return NULL;
5418 }
5419
5420 static inline void
vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceDepthStencilResolveProperties * val)5421 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthStencilResolveProperties *val)
5422 {
5423 /* skip val->{sType,pNext} */
5424 /* skip val->supportedDepthResolveModes */
5425 /* skip val->supportedStencilResolveModes */
5426 /* skip val->independentResolveNone */
5427 /* skip val->independentResolve */
5428 }
5429
5430 static inline void
vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceDepthStencilResolveProperties * val)5431 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthStencilResolveProperties *val)
5432 {
5433 VkStructureType stype;
5434 vn_decode_VkStructureType(dec, &stype);
5435 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES)
5436 vn_cs_decoder_set_fatal(dec);
5437
5438 val->sType = stype;
5439 val->pNext = vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial_temp(dec);
5440 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial_temp(dec, val);
5441 }
5442
5443 /* struct VkPhysicalDeviceTransformFeedbackPropertiesEXT chain */
5444
5445 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(struct vn_cs_encoder * enc,const void * val)5446 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
5447 {
5448 /* no known/supported struct */
5449 vn_encode_simple_pointer(enc, NULL);
5450 }
5451
5452 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)5453 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
5454 {
5455 /* skip val->{sType,pNext} */
5456 vn_encode_uint32_t(enc, &val->maxTransformFeedbackStreams);
5457 vn_encode_uint32_t(enc, &val->maxTransformFeedbackBuffers);
5458 vn_encode_VkDeviceSize(enc, &val->maxTransformFeedbackBufferSize);
5459 vn_encode_uint32_t(enc, &val->maxTransformFeedbackStreamDataSize);
5460 vn_encode_uint32_t(enc, &val->maxTransformFeedbackBufferDataSize);
5461 vn_encode_uint32_t(enc, &val->maxTransformFeedbackBufferDataStride);
5462 vn_encode_VkBool32(enc, &val->transformFeedbackQueries);
5463 vn_encode_VkBool32(enc, &val->transformFeedbackStreamsLinesTriangles);
5464 vn_encode_VkBool32(enc, &val->transformFeedbackRasterizationStreamSelect);
5465 vn_encode_VkBool32(enc, &val->transformFeedbackDraw);
5466 }
5467
5468 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)5469 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
5470 {
5471 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
5472 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT });
5473 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(enc, val->pNext);
5474 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(enc, val);
5475 }
5476
5477 static inline void *
vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial_temp(struct vn_cs_decoder * dec)5478 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial_temp(struct vn_cs_decoder *dec)
5479 {
5480 /* no known/supported struct */
5481 if (vn_decode_simple_pointer(dec))
5482 vn_cs_decoder_set_fatal(dec);
5483 return NULL;
5484 }
5485
5486 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)5487 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
5488 {
5489 /* skip val->{sType,pNext} */
5490 /* skip val->maxTransformFeedbackStreams */
5491 /* skip val->maxTransformFeedbackBuffers */
5492 /* skip val->maxTransformFeedbackBufferSize */
5493 /* skip val->maxTransformFeedbackStreamDataSize */
5494 /* skip val->maxTransformFeedbackBufferDataSize */
5495 /* skip val->maxTransformFeedbackBufferDataStride */
5496 /* skip val->transformFeedbackQueries */
5497 /* skip val->transformFeedbackStreamsLinesTriangles */
5498 /* skip val->transformFeedbackRasterizationStreamSelect */
5499 /* skip val->transformFeedbackDraw */
5500 }
5501
5502 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)5503 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
5504 {
5505 VkStructureType stype;
5506 vn_decode_VkStructureType(dec, &stype);
5507 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT)
5508 vn_cs_decoder_set_fatal(dec);
5509
5510 val->sType = stype;
5511 val->pNext = vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial_temp(dec);
5512 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial_temp(dec, val);
5513 }
5514
5515 /* struct VkPhysicalDeviceVulkan11Properties chain */
5516
5517 static inline void
vn_encode_VkPhysicalDeviceVulkan11Properties_pnext(struct vn_cs_encoder * enc,const void * val)5518 vn_encode_VkPhysicalDeviceVulkan11Properties_pnext(struct vn_cs_encoder *enc, const void *val)
5519 {
5520 /* no known/supported struct */
5521 vn_encode_simple_pointer(enc, NULL);
5522 }
5523
5524 static inline void
vn_encode_VkPhysicalDeviceVulkan11Properties_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Properties * val)5525 vn_encode_VkPhysicalDeviceVulkan11Properties_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Properties *val)
5526 {
5527 /* skip val->{sType,pNext} */
5528 vn_encode_array_size(enc, VK_UUID_SIZE);
5529 vn_encode_uint8_t_array(enc, val->deviceUUID, VK_UUID_SIZE);
5530 vn_encode_array_size(enc, VK_UUID_SIZE);
5531 vn_encode_uint8_t_array(enc, val->driverUUID, VK_UUID_SIZE);
5532 vn_encode_array_size(enc, VK_LUID_SIZE);
5533 vn_encode_uint8_t_array(enc, val->deviceLUID, VK_LUID_SIZE);
5534 vn_encode_uint32_t(enc, &val->deviceNodeMask);
5535 vn_encode_VkBool32(enc, &val->deviceLUIDValid);
5536 vn_encode_uint32_t(enc, &val->subgroupSize);
5537 vn_encode_VkFlags(enc, &val->subgroupSupportedStages);
5538 vn_encode_VkFlags(enc, &val->subgroupSupportedOperations);
5539 vn_encode_VkBool32(enc, &val->subgroupQuadOperationsInAllStages);
5540 vn_encode_VkPointClippingBehavior(enc, &val->pointClippingBehavior);
5541 vn_encode_uint32_t(enc, &val->maxMultiviewViewCount);
5542 vn_encode_uint32_t(enc, &val->maxMultiviewInstanceIndex);
5543 vn_encode_VkBool32(enc, &val->protectedNoFault);
5544 vn_encode_uint32_t(enc, &val->maxPerSetDescriptors);
5545 vn_encode_VkDeviceSize(enc, &val->maxMemoryAllocationSize);
5546 }
5547
5548 static inline void
vn_encode_VkPhysicalDeviceVulkan11Properties(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Properties * val)5549 vn_encode_VkPhysicalDeviceVulkan11Properties(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Properties *val)
5550 {
5551 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
5552 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES });
5553 vn_encode_VkPhysicalDeviceVulkan11Properties_pnext(enc, val->pNext);
5554 vn_encode_VkPhysicalDeviceVulkan11Properties_self(enc, val);
5555 }
5556
5557 static inline void *
vn_decode_VkPhysicalDeviceVulkan11Properties_pnext_partial_temp(struct vn_cs_decoder * dec)5558 vn_decode_VkPhysicalDeviceVulkan11Properties_pnext_partial_temp(struct vn_cs_decoder *dec)
5559 {
5560 /* no known/supported struct */
5561 if (vn_decode_simple_pointer(dec))
5562 vn_cs_decoder_set_fatal(dec);
5563 return NULL;
5564 }
5565
5566 static inline void
vn_decode_VkPhysicalDeviceVulkan11Properties_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Properties * val)5567 vn_decode_VkPhysicalDeviceVulkan11Properties_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Properties *val)
5568 {
5569 /* skip val->{sType,pNext} */
5570 /* skip val->deviceUUID */
5571 /* skip val->driverUUID */
5572 /* skip val->deviceLUID */
5573 /* skip val->deviceNodeMask */
5574 /* skip val->deviceLUIDValid */
5575 /* skip val->subgroupSize */
5576 /* skip val->subgroupSupportedStages */
5577 /* skip val->subgroupSupportedOperations */
5578 /* skip val->subgroupQuadOperationsInAllStages */
5579 /* skip val->pointClippingBehavior */
5580 /* skip val->maxMultiviewViewCount */
5581 /* skip val->maxMultiviewInstanceIndex */
5582 /* skip val->protectedNoFault */
5583 /* skip val->maxPerSetDescriptors */
5584 /* skip val->maxMemoryAllocationSize */
5585 }
5586
5587 static inline void
vn_decode_VkPhysicalDeviceVulkan11Properties_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Properties * val)5588 vn_decode_VkPhysicalDeviceVulkan11Properties_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Properties *val)
5589 {
5590 VkStructureType stype;
5591 vn_decode_VkStructureType(dec, &stype);
5592 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES)
5593 vn_cs_decoder_set_fatal(dec);
5594
5595 val->sType = stype;
5596 val->pNext = vn_decode_VkPhysicalDeviceVulkan11Properties_pnext_partial_temp(dec);
5597 vn_decode_VkPhysicalDeviceVulkan11Properties_self_partial_temp(dec, val);
5598 }
5599
5600 /* struct VkPhysicalDeviceVulkan12Properties chain */
5601
5602 static inline void
vn_encode_VkPhysicalDeviceVulkan12Properties_pnext(struct vn_cs_encoder * enc,const void * val)5603 vn_encode_VkPhysicalDeviceVulkan12Properties_pnext(struct vn_cs_encoder *enc, const void *val)
5604 {
5605 /* no known/supported struct */
5606 vn_encode_simple_pointer(enc, NULL);
5607 }
5608
5609 static inline void
vn_encode_VkPhysicalDeviceVulkan12Properties_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Properties * val)5610 vn_encode_VkPhysicalDeviceVulkan12Properties_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Properties *val)
5611 {
5612 /* skip val->{sType,pNext} */
5613 vn_encode_VkDriverId(enc, &val->driverID);
5614 vn_encode_array_size(enc, VK_MAX_DRIVER_NAME_SIZE);
5615 vn_encode_char_array(enc, val->driverName, VK_MAX_DRIVER_NAME_SIZE);
5616 vn_encode_array_size(enc, VK_MAX_DRIVER_INFO_SIZE);
5617 vn_encode_char_array(enc, val->driverInfo, VK_MAX_DRIVER_INFO_SIZE);
5618 vn_encode_VkConformanceVersion(enc, &val->conformanceVersion);
5619 vn_encode_VkShaderFloatControlsIndependence(enc, &val->denormBehaviorIndependence);
5620 vn_encode_VkShaderFloatControlsIndependence(enc, &val->roundingModeIndependence);
5621 vn_encode_VkBool32(enc, &val->shaderSignedZeroInfNanPreserveFloat16);
5622 vn_encode_VkBool32(enc, &val->shaderSignedZeroInfNanPreserveFloat32);
5623 vn_encode_VkBool32(enc, &val->shaderSignedZeroInfNanPreserveFloat64);
5624 vn_encode_VkBool32(enc, &val->shaderDenormPreserveFloat16);
5625 vn_encode_VkBool32(enc, &val->shaderDenormPreserveFloat32);
5626 vn_encode_VkBool32(enc, &val->shaderDenormPreserveFloat64);
5627 vn_encode_VkBool32(enc, &val->shaderDenormFlushToZeroFloat16);
5628 vn_encode_VkBool32(enc, &val->shaderDenormFlushToZeroFloat32);
5629 vn_encode_VkBool32(enc, &val->shaderDenormFlushToZeroFloat64);
5630 vn_encode_VkBool32(enc, &val->shaderRoundingModeRTEFloat16);
5631 vn_encode_VkBool32(enc, &val->shaderRoundingModeRTEFloat32);
5632 vn_encode_VkBool32(enc, &val->shaderRoundingModeRTEFloat64);
5633 vn_encode_VkBool32(enc, &val->shaderRoundingModeRTZFloat16);
5634 vn_encode_VkBool32(enc, &val->shaderRoundingModeRTZFloat32);
5635 vn_encode_VkBool32(enc, &val->shaderRoundingModeRTZFloat64);
5636 vn_encode_uint32_t(enc, &val->maxUpdateAfterBindDescriptorsInAllPools);
5637 vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayNonUniformIndexingNative);
5638 vn_encode_VkBool32(enc, &val->shaderSampledImageArrayNonUniformIndexingNative);
5639 vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayNonUniformIndexingNative);
5640 vn_encode_VkBool32(enc, &val->shaderStorageImageArrayNonUniformIndexingNative);
5641 vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayNonUniformIndexingNative);
5642 vn_encode_VkBool32(enc, &val->robustBufferAccessUpdateAfterBind);
5643 vn_encode_VkBool32(enc, &val->quadDivergentImplicitLod);
5644 vn_encode_uint32_t(enc, &val->maxPerStageDescriptorUpdateAfterBindSamplers);
5645 vn_encode_uint32_t(enc, &val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
5646 vn_encode_uint32_t(enc, &val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
5647 vn_encode_uint32_t(enc, &val->maxPerStageDescriptorUpdateAfterBindSampledImages);
5648 vn_encode_uint32_t(enc, &val->maxPerStageDescriptorUpdateAfterBindStorageImages);
5649 vn_encode_uint32_t(enc, &val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
5650 vn_encode_uint32_t(enc, &val->maxPerStageUpdateAfterBindResources);
5651 vn_encode_uint32_t(enc, &val->maxDescriptorSetUpdateAfterBindSamplers);
5652 vn_encode_uint32_t(enc, &val->maxDescriptorSetUpdateAfterBindUniformBuffers);
5653 vn_encode_uint32_t(enc, &val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
5654 vn_encode_uint32_t(enc, &val->maxDescriptorSetUpdateAfterBindStorageBuffers);
5655 vn_encode_uint32_t(enc, &val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
5656 vn_encode_uint32_t(enc, &val->maxDescriptorSetUpdateAfterBindSampledImages);
5657 vn_encode_uint32_t(enc, &val->maxDescriptorSetUpdateAfterBindStorageImages);
5658 vn_encode_uint32_t(enc, &val->maxDescriptorSetUpdateAfterBindInputAttachments);
5659 vn_encode_VkFlags(enc, &val->supportedDepthResolveModes);
5660 vn_encode_VkFlags(enc, &val->supportedStencilResolveModes);
5661 vn_encode_VkBool32(enc, &val->independentResolveNone);
5662 vn_encode_VkBool32(enc, &val->independentResolve);
5663 vn_encode_VkBool32(enc, &val->filterMinmaxSingleComponentFormats);
5664 vn_encode_VkBool32(enc, &val->filterMinmaxImageComponentMapping);
5665 vn_encode_uint64_t(enc, &val->maxTimelineSemaphoreValueDifference);
5666 vn_encode_VkFlags(enc, &val->framebufferIntegerColorSampleCounts);
5667 }
5668
5669 static inline void
vn_encode_VkPhysicalDeviceVulkan12Properties(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Properties * val)5670 vn_encode_VkPhysicalDeviceVulkan12Properties(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Properties *val)
5671 {
5672 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
5673 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES });
5674 vn_encode_VkPhysicalDeviceVulkan12Properties_pnext(enc, val->pNext);
5675 vn_encode_VkPhysicalDeviceVulkan12Properties_self(enc, val);
5676 }
5677
5678 static inline void *
vn_decode_VkPhysicalDeviceVulkan12Properties_pnext_partial_temp(struct vn_cs_decoder * dec)5679 vn_decode_VkPhysicalDeviceVulkan12Properties_pnext_partial_temp(struct vn_cs_decoder *dec)
5680 {
5681 /* no known/supported struct */
5682 if (vn_decode_simple_pointer(dec))
5683 vn_cs_decoder_set_fatal(dec);
5684 return NULL;
5685 }
5686
5687 static inline void
vn_decode_VkPhysicalDeviceVulkan12Properties_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Properties * val)5688 vn_decode_VkPhysicalDeviceVulkan12Properties_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Properties *val)
5689 {
5690 /* skip val->{sType,pNext} */
5691 /* skip val->driverID */
5692 /* skip val->driverName */
5693 /* skip val->driverInfo */
5694 vn_decode_VkConformanceVersion_partial_temp(dec, &val->conformanceVersion);
5695 /* skip val->denormBehaviorIndependence */
5696 /* skip val->roundingModeIndependence */
5697 /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
5698 /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
5699 /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
5700 /* skip val->shaderDenormPreserveFloat16 */
5701 /* skip val->shaderDenormPreserveFloat32 */
5702 /* skip val->shaderDenormPreserveFloat64 */
5703 /* skip val->shaderDenormFlushToZeroFloat16 */
5704 /* skip val->shaderDenormFlushToZeroFloat32 */
5705 /* skip val->shaderDenormFlushToZeroFloat64 */
5706 /* skip val->shaderRoundingModeRTEFloat16 */
5707 /* skip val->shaderRoundingModeRTEFloat32 */
5708 /* skip val->shaderRoundingModeRTEFloat64 */
5709 /* skip val->shaderRoundingModeRTZFloat16 */
5710 /* skip val->shaderRoundingModeRTZFloat32 */
5711 /* skip val->shaderRoundingModeRTZFloat64 */
5712 /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
5713 /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
5714 /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
5715 /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
5716 /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
5717 /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
5718 /* skip val->robustBufferAccessUpdateAfterBind */
5719 /* skip val->quadDivergentImplicitLod */
5720 /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
5721 /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
5722 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
5723 /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
5724 /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
5725 /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
5726 /* skip val->maxPerStageUpdateAfterBindResources */
5727 /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
5728 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
5729 /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
5730 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
5731 /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
5732 /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
5733 /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
5734 /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
5735 /* skip val->supportedDepthResolveModes */
5736 /* skip val->supportedStencilResolveModes */
5737 /* skip val->independentResolveNone */
5738 /* skip val->independentResolve */
5739 /* skip val->filterMinmaxSingleComponentFormats */
5740 /* skip val->filterMinmaxImageComponentMapping */
5741 /* skip val->maxTimelineSemaphoreValueDifference */
5742 /* skip val->framebufferIntegerColorSampleCounts */
5743 }
5744
5745 static inline void
vn_decode_VkPhysicalDeviceVulkan12Properties_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Properties * val)5746 vn_decode_VkPhysicalDeviceVulkan12Properties_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Properties *val)
5747 {
5748 VkStructureType stype;
5749 vn_decode_VkStructureType(dec, &stype);
5750 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES)
5751 vn_cs_decoder_set_fatal(dec);
5752
5753 val->sType = stype;
5754 val->pNext = vn_decode_VkPhysicalDeviceVulkan12Properties_pnext_partial_temp(dec);
5755 vn_decode_VkPhysicalDeviceVulkan12Properties_self_partial_temp(dec, val);
5756 }
5757
5758 /* struct VkPhysicalDeviceProperties2 chain */
5759
5760 static inline void
vn_encode_VkPhysicalDeviceProperties2_pnext(struct vn_cs_encoder * enc,const void * val)5761 vn_encode_VkPhysicalDeviceProperties2_pnext(struct vn_cs_encoder *enc, const void *val)
5762 {
5763 const VkBaseInStructure *pnext = val;
5764
5765 while (pnext) {
5766 switch ((int32_t)pnext->sType) {
5767 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
5768 vn_encode_simple_pointer(enc, pnext);
5769 vn_encode_VkStructureType(enc, &pnext->sType);
5770 vn_encode_VkPhysicalDeviceProperties2_pnext(enc, pnext->pNext);
5771 vn_encode_VkPhysicalDeviceDriverProperties_self(enc, (const VkPhysicalDeviceDriverProperties *)pnext);
5772 return;
5773 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
5774 vn_encode_simple_pointer(enc, pnext);
5775 vn_encode_VkStructureType(enc, &pnext->sType);
5776 vn_encode_VkPhysicalDeviceProperties2_pnext(enc, pnext->pNext);
5777 vn_encode_VkPhysicalDeviceIDProperties_self(enc, (const VkPhysicalDeviceIDProperties *)pnext);
5778 return;
5779 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
5780 vn_encode_simple_pointer(enc, pnext);
5781 vn_encode_VkStructureType(enc, &pnext->sType);
5782 vn_encode_VkPhysicalDeviceProperties2_pnext(enc, pnext->pNext);
5783 vn_encode_VkPhysicalDeviceMultiviewProperties_self(enc, (const VkPhysicalDeviceMultiviewProperties *)pnext);
5784 return;
5785 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
5786 vn_encode_simple_pointer(enc, pnext);
5787 vn_encode_VkStructureType(enc, &pnext->sType);
5788 vn_encode_VkPhysicalDeviceProperties2_pnext(enc, pnext->pNext);
5789 vn_encode_VkPhysicalDeviceSubgroupProperties_self(enc, (const VkPhysicalDeviceSubgroupProperties *)pnext);
5790 return;
5791 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
5792 vn_encode_simple_pointer(enc, pnext);
5793 vn_encode_VkStructureType(enc, &pnext->sType);
5794 vn_encode_VkPhysicalDeviceProperties2_pnext(enc, pnext->pNext);
5795 vn_encode_VkPhysicalDevicePointClippingProperties_self(enc, (const VkPhysicalDevicePointClippingProperties *)pnext);
5796 return;
5797 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
5798 vn_encode_simple_pointer(enc, pnext);
5799 vn_encode_VkStructureType(enc, &pnext->sType);
5800 vn_encode_VkPhysicalDeviceProperties2_pnext(enc, pnext->pNext);
5801 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self(enc, (const VkPhysicalDeviceProtectedMemoryProperties *)pnext);
5802 return;
5803 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
5804 vn_encode_simple_pointer(enc, pnext);
5805 vn_encode_VkStructureType(enc, &pnext->sType);
5806 vn_encode_VkPhysicalDeviceProperties2_pnext(enc, pnext->pNext);
5807 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(enc, (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
5808 return;
5809 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
5810 vn_encode_simple_pointer(enc, pnext);
5811 vn_encode_VkStructureType(enc, &pnext->sType);
5812 vn_encode_VkPhysicalDeviceProperties2_pnext(enc, pnext->pNext);
5813 vn_encode_VkPhysicalDeviceMaintenance3Properties_self(enc, (const VkPhysicalDeviceMaintenance3Properties *)pnext);
5814 return;
5815 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
5816 vn_encode_simple_pointer(enc, pnext);
5817 vn_encode_VkStructureType(enc, &pnext->sType);
5818 vn_encode_VkPhysicalDeviceProperties2_pnext(enc, pnext->pNext);
5819 vn_encode_VkPhysicalDeviceFloatControlsProperties_self(enc, (const VkPhysicalDeviceFloatControlsProperties *)pnext);
5820 return;
5821 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
5822 vn_encode_simple_pointer(enc, pnext);
5823 vn_encode_VkStructureType(enc, &pnext->sType);
5824 vn_encode_VkPhysicalDeviceProperties2_pnext(enc, pnext->pNext);
5825 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self(enc, (const VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
5826 return;
5827 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
5828 vn_encode_simple_pointer(enc, pnext);
5829 vn_encode_VkStructureType(enc, &pnext->sType);
5830 vn_encode_VkPhysicalDeviceProperties2_pnext(enc, pnext->pNext);
5831 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self(enc, (const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
5832 return;
5833 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
5834 vn_encode_simple_pointer(enc, pnext);
5835 vn_encode_VkStructureType(enc, &pnext->sType);
5836 vn_encode_VkPhysicalDeviceProperties2_pnext(enc, pnext->pNext);
5837 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self(enc, (const VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
5838 return;
5839 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
5840 vn_encode_simple_pointer(enc, pnext);
5841 vn_encode_VkStructureType(enc, &pnext->sType);
5842 vn_encode_VkPhysicalDeviceProperties2_pnext(enc, pnext->pNext);
5843 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(enc, (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
5844 return;
5845 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
5846 vn_encode_simple_pointer(enc, pnext);
5847 vn_encode_VkStructureType(enc, &pnext->sType);
5848 vn_encode_VkPhysicalDeviceProperties2_pnext(enc, pnext->pNext);
5849 vn_encode_VkPhysicalDeviceVulkan11Properties_self(enc, (const VkPhysicalDeviceVulkan11Properties *)pnext);
5850 return;
5851 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
5852 vn_encode_simple_pointer(enc, pnext);
5853 vn_encode_VkStructureType(enc, &pnext->sType);
5854 vn_encode_VkPhysicalDeviceProperties2_pnext(enc, pnext->pNext);
5855 vn_encode_VkPhysicalDeviceVulkan12Properties_self(enc, (const VkPhysicalDeviceVulkan12Properties *)pnext);
5856 return;
5857 default:
5858 /* ignore unknown/unsupported struct */
5859 break;
5860 }
5861 pnext = pnext->pNext;
5862 }
5863
5864 vn_encode_simple_pointer(enc, NULL);
5865 }
5866
5867 static inline void
vn_encode_VkPhysicalDeviceProperties2_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceProperties2 * val)5868 vn_encode_VkPhysicalDeviceProperties2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties2 *val)
5869 {
5870 /* skip val->{sType,pNext} */
5871 vn_encode_VkPhysicalDeviceProperties(enc, &val->properties);
5872 }
5873
5874 static inline void
vn_encode_VkPhysicalDeviceProperties2(struct vn_cs_encoder * enc,const VkPhysicalDeviceProperties2 * val)5875 vn_encode_VkPhysicalDeviceProperties2(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties2 *val)
5876 {
5877 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);
5878 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 });
5879 vn_encode_VkPhysicalDeviceProperties2_pnext(enc, val->pNext);
5880 vn_encode_VkPhysicalDeviceProperties2_self(enc, val);
5881 }
5882
5883 static inline void *
vn_decode_VkPhysicalDeviceProperties2_pnext_partial_temp(struct vn_cs_decoder * dec)5884 vn_decode_VkPhysicalDeviceProperties2_pnext_partial_temp(struct vn_cs_decoder *dec)
5885 {
5886 VkBaseOutStructure *pnext;
5887 VkStructureType stype;
5888
5889 if (!vn_decode_simple_pointer(dec))
5890 return NULL;
5891
5892 vn_decode_VkStructureType(dec, &stype);
5893 switch ((int32_t)stype) {
5894 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
5895 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceDriverProperties));
5896 if (pnext) {
5897 pnext->sType = stype;
5898 pnext->pNext = vn_decode_VkPhysicalDeviceProperties2_pnext_partial_temp(dec);
5899 vn_decode_VkPhysicalDeviceDriverProperties_self_partial_temp(dec, (VkPhysicalDeviceDriverProperties *)pnext);
5900 }
5901 break;
5902 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
5903 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceIDProperties));
5904 if (pnext) {
5905 pnext->sType = stype;
5906 pnext->pNext = vn_decode_VkPhysicalDeviceProperties2_pnext_partial_temp(dec);
5907 vn_decode_VkPhysicalDeviceIDProperties_self_partial_temp(dec, (VkPhysicalDeviceIDProperties *)pnext);
5908 }
5909 break;
5910 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
5911 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceMultiviewProperties));
5912 if (pnext) {
5913 pnext->sType = stype;
5914 pnext->pNext = vn_decode_VkPhysicalDeviceProperties2_pnext_partial_temp(dec);
5915 vn_decode_VkPhysicalDeviceMultiviewProperties_self_partial_temp(dec, (VkPhysicalDeviceMultiviewProperties *)pnext);
5916 }
5917 break;
5918 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
5919 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceSubgroupProperties));
5920 if (pnext) {
5921 pnext->sType = stype;
5922 pnext->pNext = vn_decode_VkPhysicalDeviceProperties2_pnext_partial_temp(dec);
5923 vn_decode_VkPhysicalDeviceSubgroupProperties_self_partial_temp(dec, (VkPhysicalDeviceSubgroupProperties *)pnext);
5924 }
5925 break;
5926 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
5927 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDevicePointClippingProperties));
5928 if (pnext) {
5929 pnext->sType = stype;
5930 pnext->pNext = vn_decode_VkPhysicalDeviceProperties2_pnext_partial_temp(dec);
5931 vn_decode_VkPhysicalDevicePointClippingProperties_self_partial_temp(dec, (VkPhysicalDevicePointClippingProperties *)pnext);
5932 }
5933 break;
5934 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
5935 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceProtectedMemoryProperties));
5936 if (pnext) {
5937 pnext->sType = stype;
5938 pnext->pNext = vn_decode_VkPhysicalDeviceProperties2_pnext_partial_temp(dec);
5939 vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self_partial_temp(dec, (VkPhysicalDeviceProtectedMemoryProperties *)pnext);
5940 }
5941 break;
5942 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
5943 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceSamplerFilterMinmaxProperties));
5944 if (pnext) {
5945 pnext->sType = stype;
5946 pnext->pNext = vn_decode_VkPhysicalDeviceProperties2_pnext_partial_temp(dec);
5947 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial_temp(dec, (VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
5948 }
5949 break;
5950 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
5951 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceMaintenance3Properties));
5952 if (pnext) {
5953 pnext->sType = stype;
5954 pnext->pNext = vn_decode_VkPhysicalDeviceProperties2_pnext_partial_temp(dec);
5955 vn_decode_VkPhysicalDeviceMaintenance3Properties_self_partial_temp(dec, (VkPhysicalDeviceMaintenance3Properties *)pnext);
5956 }
5957 break;
5958 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
5959 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceFloatControlsProperties));
5960 if (pnext) {
5961 pnext->sType = stype;
5962 pnext->pNext = vn_decode_VkPhysicalDeviceProperties2_pnext_partial_temp(dec);
5963 vn_decode_VkPhysicalDeviceFloatControlsProperties_self_partial_temp(dec, (VkPhysicalDeviceFloatControlsProperties *)pnext);
5964 }
5965 break;
5966 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
5967 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceDescriptorIndexingProperties));
5968 if (pnext) {
5969 pnext->sType = stype;
5970 pnext->pNext = vn_decode_VkPhysicalDeviceProperties2_pnext_partial_temp(dec);
5971 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial_temp(dec, (VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
5972 }
5973 break;
5974 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
5975 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceTimelineSemaphoreProperties));
5976 if (pnext) {
5977 pnext->sType = stype;
5978 pnext->pNext = vn_decode_VkPhysicalDeviceProperties2_pnext_partial_temp(dec);
5979 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial_temp(dec, (VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
5980 }
5981 break;
5982 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
5983 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceDepthStencilResolveProperties));
5984 if (pnext) {
5985 pnext->sType = stype;
5986 pnext->pNext = vn_decode_VkPhysicalDeviceProperties2_pnext_partial_temp(dec);
5987 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial_temp(dec, (VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
5988 }
5989 break;
5990 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
5991 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceTransformFeedbackPropertiesEXT));
5992 if (pnext) {
5993 pnext->sType = stype;
5994 pnext->pNext = vn_decode_VkPhysicalDeviceProperties2_pnext_partial_temp(dec);
5995 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial_temp(dec, (VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
5996 }
5997 break;
5998 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
5999 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceVulkan11Properties));
6000 if (pnext) {
6001 pnext->sType = stype;
6002 pnext->pNext = vn_decode_VkPhysicalDeviceProperties2_pnext_partial_temp(dec);
6003 vn_decode_VkPhysicalDeviceVulkan11Properties_self_partial_temp(dec, (VkPhysicalDeviceVulkan11Properties *)pnext);
6004 }
6005 break;
6006 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
6007 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceVulkan12Properties));
6008 if (pnext) {
6009 pnext->sType = stype;
6010 pnext->pNext = vn_decode_VkPhysicalDeviceProperties2_pnext_partial_temp(dec);
6011 vn_decode_VkPhysicalDeviceVulkan12Properties_self_partial_temp(dec, (VkPhysicalDeviceVulkan12Properties *)pnext);
6012 }
6013 break;
6014 default:
6015 /* unexpected struct */
6016 pnext = NULL;
6017 vn_cs_decoder_set_fatal(dec);
6018 break;
6019 }
6020
6021 return pnext;
6022 }
6023
6024 static inline void
vn_decode_VkPhysicalDeviceProperties2_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceProperties2 * val)6025 vn_decode_VkPhysicalDeviceProperties2_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties2 *val)
6026 {
6027 /* skip val->{sType,pNext} */
6028 vn_decode_VkPhysicalDeviceProperties_partial_temp(dec, &val->properties);
6029 }
6030
6031 static inline void
vn_decode_VkPhysicalDeviceProperties2_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceProperties2 * val)6032 vn_decode_VkPhysicalDeviceProperties2_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties2 *val)
6033 {
6034 VkStructureType stype;
6035 vn_decode_VkStructureType(dec, &stype);
6036 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2)
6037 vn_cs_decoder_set_fatal(dec);
6038
6039 val->sType = stype;
6040 val->pNext = vn_decode_VkPhysicalDeviceProperties2_pnext_partial_temp(dec);
6041 vn_decode_VkPhysicalDeviceProperties2_self_partial_temp(dec, val);
6042 }
6043
6044 /* struct VkDrmFormatModifierPropertiesEXT */
6045
6046 static inline void
vn_encode_VkDrmFormatModifierPropertiesEXT(struct vn_cs_encoder * enc,const VkDrmFormatModifierPropertiesEXT * val)6047 vn_encode_VkDrmFormatModifierPropertiesEXT(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesEXT *val)
6048 {
6049 vn_encode_uint64_t(enc, &val->drmFormatModifier);
6050 vn_encode_uint32_t(enc, &val->drmFormatModifierPlaneCount);
6051 vn_encode_VkFlags(enc, &val->drmFormatModifierTilingFeatures);
6052 }
6053
6054 static inline void
vn_decode_VkDrmFormatModifierPropertiesEXT_partial_temp(struct vn_cs_decoder * dec,VkDrmFormatModifierPropertiesEXT * val)6055 vn_decode_VkDrmFormatModifierPropertiesEXT_partial_temp(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesEXT *val)
6056 {
6057 /* skip val->drmFormatModifier */
6058 /* skip val->drmFormatModifierPlaneCount */
6059 /* skip val->drmFormatModifierTilingFeatures */
6060 }
6061
6062 /* struct VkDrmFormatModifierPropertiesListEXT chain */
6063
6064 static inline void
vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext(struct vn_cs_encoder * enc,const void * val)6065 vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext(struct vn_cs_encoder *enc, const void *val)
6066 {
6067 /* no known/supported struct */
6068 vn_encode_simple_pointer(enc, NULL);
6069 }
6070
6071 static inline void
vn_encode_VkDrmFormatModifierPropertiesListEXT_self(struct vn_cs_encoder * enc,const VkDrmFormatModifierPropertiesListEXT * val)6072 vn_encode_VkDrmFormatModifierPropertiesListEXT_self(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesListEXT *val)
6073 {
6074 /* skip val->{sType,pNext} */
6075 vn_encode_uint32_t(enc, &val->drmFormatModifierCount);
6076 if (val->pDrmFormatModifierProperties) {
6077 vn_encode_array_size(enc, val->drmFormatModifierCount);
6078 for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
6079 vn_encode_VkDrmFormatModifierPropertiesEXT(enc, &val->pDrmFormatModifierProperties[i]);
6080 } else {
6081 vn_encode_array_size(enc, 0);
6082 }
6083 }
6084
6085 static inline void
vn_encode_VkDrmFormatModifierPropertiesListEXT(struct vn_cs_encoder * enc,const VkDrmFormatModifierPropertiesListEXT * val)6086 vn_encode_VkDrmFormatModifierPropertiesListEXT(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesListEXT *val)
6087 {
6088 assert(val->sType == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT);
6089 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT });
6090 vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext(enc, val->pNext);
6091 vn_encode_VkDrmFormatModifierPropertiesListEXT_self(enc, val);
6092 }
6093
6094 static inline void *
vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext_partial_temp(struct vn_cs_decoder * dec)6095 vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext_partial_temp(struct vn_cs_decoder *dec)
6096 {
6097 /* no known/supported struct */
6098 if (vn_decode_simple_pointer(dec))
6099 vn_cs_decoder_set_fatal(dec);
6100 return NULL;
6101 }
6102
6103 static inline void
vn_decode_VkDrmFormatModifierPropertiesListEXT_self_partial_temp(struct vn_cs_decoder * dec,VkDrmFormatModifierPropertiesListEXT * val)6104 vn_decode_VkDrmFormatModifierPropertiesListEXT_self_partial_temp(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesListEXT *val)
6105 {
6106 /* skip val->{sType,pNext} */
6107 /* WA1 */ val->drmFormatModifierCount = vn_peek_array_size(dec);
6108 if (vn_peek_array_size(dec)) {
6109 const uint32_t iter_count = vn_decode_array_size(dec, val->drmFormatModifierCount);
6110 val->pDrmFormatModifierProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pDrmFormatModifierProperties) * iter_count);
6111 if (!val->pDrmFormatModifierProperties) return;
6112 for (uint32_t i = 0; i < iter_count; i++)
6113 vn_decode_VkDrmFormatModifierPropertiesEXT_partial_temp(dec, &val->pDrmFormatModifierProperties[i]);
6114 } else {
6115 vn_decode_array_size_unchecked(dec);
6116 val->pDrmFormatModifierProperties = NULL;
6117 }
6118 }
6119
6120 static inline void
vn_decode_VkDrmFormatModifierPropertiesListEXT_partial_temp(struct vn_cs_decoder * dec,VkDrmFormatModifierPropertiesListEXT * val)6121 vn_decode_VkDrmFormatModifierPropertiesListEXT_partial_temp(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesListEXT *val)
6122 {
6123 VkStructureType stype;
6124 vn_decode_VkStructureType(dec, &stype);
6125 if (stype != VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT)
6126 vn_cs_decoder_set_fatal(dec);
6127
6128 val->sType = stype;
6129 val->pNext = vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext_partial_temp(dec);
6130 vn_decode_VkDrmFormatModifierPropertiesListEXT_self_partial_temp(dec, val);
6131 }
6132
6133 /* struct VkFormatProperties2 chain */
6134
6135 static inline void
vn_encode_VkFormatProperties2_pnext(struct vn_cs_encoder * enc,const void * val)6136 vn_encode_VkFormatProperties2_pnext(struct vn_cs_encoder *enc, const void *val)
6137 {
6138 const VkBaseInStructure *pnext = val;
6139
6140 while (pnext) {
6141 switch ((int32_t)pnext->sType) {
6142 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
6143 vn_encode_simple_pointer(enc, pnext);
6144 vn_encode_VkStructureType(enc, &pnext->sType);
6145 vn_encode_VkFormatProperties2_pnext(enc, pnext->pNext);
6146 vn_encode_VkDrmFormatModifierPropertiesListEXT_self(enc, (const VkDrmFormatModifierPropertiesListEXT *)pnext);
6147 return;
6148 default:
6149 /* ignore unknown/unsupported struct */
6150 break;
6151 }
6152 pnext = pnext->pNext;
6153 }
6154
6155 vn_encode_simple_pointer(enc, NULL);
6156 }
6157
6158 static inline void
vn_encode_VkFormatProperties2_self(struct vn_cs_encoder * enc,const VkFormatProperties2 * val)6159 vn_encode_VkFormatProperties2_self(struct vn_cs_encoder *enc, const VkFormatProperties2 *val)
6160 {
6161 /* skip val->{sType,pNext} */
6162 vn_encode_VkFormatProperties(enc, &val->formatProperties);
6163 }
6164
6165 static inline void
vn_encode_VkFormatProperties2(struct vn_cs_encoder * enc,const VkFormatProperties2 * val)6166 vn_encode_VkFormatProperties2(struct vn_cs_encoder *enc, const VkFormatProperties2 *val)
6167 {
6168 assert(val->sType == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
6169 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 });
6170 vn_encode_VkFormatProperties2_pnext(enc, val->pNext);
6171 vn_encode_VkFormatProperties2_self(enc, val);
6172 }
6173
6174 static inline void *
vn_decode_VkFormatProperties2_pnext_partial_temp(struct vn_cs_decoder * dec)6175 vn_decode_VkFormatProperties2_pnext_partial_temp(struct vn_cs_decoder *dec)
6176 {
6177 VkBaseOutStructure *pnext;
6178 VkStructureType stype;
6179
6180 if (!vn_decode_simple_pointer(dec))
6181 return NULL;
6182
6183 vn_decode_VkStructureType(dec, &stype);
6184 switch ((int32_t)stype) {
6185 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
6186 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkDrmFormatModifierPropertiesListEXT));
6187 if (pnext) {
6188 pnext->sType = stype;
6189 pnext->pNext = vn_decode_VkFormatProperties2_pnext_partial_temp(dec);
6190 vn_decode_VkDrmFormatModifierPropertiesListEXT_self_partial_temp(dec, (VkDrmFormatModifierPropertiesListEXT *)pnext);
6191 }
6192 break;
6193 default:
6194 /* unexpected struct */
6195 pnext = NULL;
6196 vn_cs_decoder_set_fatal(dec);
6197 break;
6198 }
6199
6200 return pnext;
6201 }
6202
6203 static inline void
vn_decode_VkFormatProperties2_self_partial_temp(struct vn_cs_decoder * dec,VkFormatProperties2 * val)6204 vn_decode_VkFormatProperties2_self_partial_temp(struct vn_cs_decoder *dec, VkFormatProperties2 *val)
6205 {
6206 /* skip val->{sType,pNext} */
6207 vn_decode_VkFormatProperties_partial_temp(dec, &val->formatProperties);
6208 }
6209
6210 static inline void
vn_decode_VkFormatProperties2_partial_temp(struct vn_cs_decoder * dec,VkFormatProperties2 * val)6211 vn_decode_VkFormatProperties2_partial_temp(struct vn_cs_decoder *dec, VkFormatProperties2 *val)
6212 {
6213 VkStructureType stype;
6214 vn_decode_VkStructureType(dec, &stype);
6215 if (stype != VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2)
6216 vn_cs_decoder_set_fatal(dec);
6217
6218 val->sType = stype;
6219 val->pNext = vn_decode_VkFormatProperties2_pnext_partial_temp(dec);
6220 vn_decode_VkFormatProperties2_self_partial_temp(dec, val);
6221 }
6222
6223 /* struct VkPhysicalDeviceExternalImageFormatInfo chain */
6224
6225 static inline void *
vn_decode_VkPhysicalDeviceExternalImageFormatInfo_pnext_temp(struct vn_cs_decoder * dec)6226 vn_decode_VkPhysicalDeviceExternalImageFormatInfo_pnext_temp(struct vn_cs_decoder *dec)
6227 {
6228 /* no known/supported struct */
6229 if (vn_decode_simple_pointer(dec))
6230 vn_cs_decoder_set_fatal(dec);
6231 return NULL;
6232 }
6233
6234 static inline void
vn_decode_VkPhysicalDeviceExternalImageFormatInfo_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceExternalImageFormatInfo * val)6235 vn_decode_VkPhysicalDeviceExternalImageFormatInfo_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceExternalImageFormatInfo *val)
6236 {
6237 /* skip val->{sType,pNext} */
6238 vn_decode_VkExternalMemoryHandleTypeFlagBits(dec, &val->handleType);
6239 }
6240
6241 static inline void
vn_decode_VkPhysicalDeviceExternalImageFormatInfo_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceExternalImageFormatInfo * val)6242 vn_decode_VkPhysicalDeviceExternalImageFormatInfo_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceExternalImageFormatInfo *val)
6243 {
6244 VkStructureType stype;
6245 vn_decode_VkStructureType(dec, &stype);
6246 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO)
6247 vn_cs_decoder_set_fatal(dec);
6248
6249 val->sType = stype;
6250 val->pNext = vn_decode_VkPhysicalDeviceExternalImageFormatInfo_pnext_temp(dec);
6251 vn_decode_VkPhysicalDeviceExternalImageFormatInfo_self_temp(dec, val);
6252 }
6253
6254 static inline void
vn_replace_VkPhysicalDeviceExternalImageFormatInfo_handle_self(VkPhysicalDeviceExternalImageFormatInfo * val)6255 vn_replace_VkPhysicalDeviceExternalImageFormatInfo_handle_self(VkPhysicalDeviceExternalImageFormatInfo *val)
6256 {
6257 /* skip val->sType */
6258 /* skip val->pNext */
6259 /* skip val->handleType */
6260 }
6261
6262 static inline void
vn_replace_VkPhysicalDeviceExternalImageFormatInfo_handle(VkPhysicalDeviceExternalImageFormatInfo * val)6263 vn_replace_VkPhysicalDeviceExternalImageFormatInfo_handle(VkPhysicalDeviceExternalImageFormatInfo *val)
6264 {
6265 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
6266
6267 do {
6268 switch ((int32_t)pnext->sType) {
6269 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
6270 vn_replace_VkPhysicalDeviceExternalImageFormatInfo_handle_self((VkPhysicalDeviceExternalImageFormatInfo *)pnext);
6271 break;
6272 default:
6273 /* ignore unknown/unsupported struct */
6274 break;
6275 }
6276 pnext = pnext->pNext;
6277 } while (pnext);
6278 }
6279
6280 /* struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT chain */
6281
6282 static inline void *
vn_decode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext_temp(struct vn_cs_decoder * dec)6283 vn_decode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext_temp(struct vn_cs_decoder *dec)
6284 {
6285 /* no known/supported struct */
6286 if (vn_decode_simple_pointer(dec))
6287 vn_cs_decoder_set_fatal(dec);
6288 return NULL;
6289 }
6290
6291 static inline void
vn_decode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)6292 vn_decode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
6293 {
6294 /* skip val->{sType,pNext} */
6295 vn_decode_uint64_t(dec, &val->drmFormatModifier);
6296 vn_decode_VkSharingMode(dec, &val->sharingMode);
6297 vn_decode_uint32_t(dec, &val->queueFamilyIndexCount);
6298 if (vn_peek_array_size(dec)) {
6299 const size_t array_size = vn_decode_array_size(dec, val->queueFamilyIndexCount);
6300 val->pQueueFamilyIndices = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pQueueFamilyIndices) * array_size);
6301 if (!val->pQueueFamilyIndices) return;
6302 vn_decode_uint32_t_array(dec, (uint32_t *)val->pQueueFamilyIndices, array_size);
6303 } else {
6304 vn_decode_array_size_unchecked(dec);
6305 val->pQueueFamilyIndices = NULL;
6306 }
6307 }
6308
6309 static inline void
vn_decode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)6310 vn_decode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
6311 {
6312 VkStructureType stype;
6313 vn_decode_VkStructureType(dec, &stype);
6314 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT)
6315 vn_cs_decoder_set_fatal(dec);
6316
6317 val->sType = stype;
6318 val->pNext = vn_decode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext_temp(dec);
6319 vn_decode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self_temp(dec, val);
6320 }
6321
6322 static inline void
vn_replace_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_handle_self(VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)6323 vn_replace_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_handle_self(VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
6324 {
6325 /* skip val->sType */
6326 /* skip val->pNext */
6327 /* skip val->drmFormatModifier */
6328 /* skip val->sharingMode */
6329 /* skip val->queueFamilyIndexCount */
6330 /* skip val->pQueueFamilyIndices */
6331 }
6332
6333 static inline void
vn_replace_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_handle(VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)6334 vn_replace_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_handle(VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
6335 {
6336 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
6337
6338 do {
6339 switch ((int32_t)pnext->sType) {
6340 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
6341 vn_replace_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_handle_self((VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)pnext);
6342 break;
6343 default:
6344 /* ignore unknown/unsupported struct */
6345 break;
6346 }
6347 pnext = pnext->pNext;
6348 } while (pnext);
6349 }
6350
6351 /* struct VkPhysicalDeviceImageFormatInfo2 chain */
6352
6353 static inline void *
vn_decode_VkPhysicalDeviceImageFormatInfo2_pnext_temp(struct vn_cs_decoder * dec)6354 vn_decode_VkPhysicalDeviceImageFormatInfo2_pnext_temp(struct vn_cs_decoder *dec)
6355 {
6356 VkBaseOutStructure *pnext;
6357 VkStructureType stype;
6358
6359 if (!vn_decode_simple_pointer(dec))
6360 return NULL;
6361
6362 vn_decode_VkStructureType(dec, &stype);
6363 switch ((int32_t)stype) {
6364 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
6365 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceExternalImageFormatInfo));
6366 if (pnext) {
6367 pnext->sType = stype;
6368 pnext->pNext = vn_decode_VkPhysicalDeviceImageFormatInfo2_pnext_temp(dec);
6369 vn_decode_VkPhysicalDeviceExternalImageFormatInfo_self_temp(dec, (VkPhysicalDeviceExternalImageFormatInfo *)pnext);
6370 }
6371 break;
6372 case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
6373 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkImageFormatListCreateInfo));
6374 if (pnext) {
6375 pnext->sType = stype;
6376 pnext->pNext = vn_decode_VkPhysicalDeviceImageFormatInfo2_pnext_temp(dec);
6377 vn_decode_VkImageFormatListCreateInfo_self_temp(dec, (VkImageFormatListCreateInfo *)pnext);
6378 }
6379 break;
6380 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
6381 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPhysicalDeviceImageDrmFormatModifierInfoEXT));
6382 if (pnext) {
6383 pnext->sType = stype;
6384 pnext->pNext = vn_decode_VkPhysicalDeviceImageFormatInfo2_pnext_temp(dec);
6385 vn_decode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self_temp(dec, (VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)pnext);
6386 }
6387 break;
6388 case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
6389 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkImageStencilUsageCreateInfo));
6390 if (pnext) {
6391 pnext->sType = stype;
6392 pnext->pNext = vn_decode_VkPhysicalDeviceImageFormatInfo2_pnext_temp(dec);
6393 vn_decode_VkImageStencilUsageCreateInfo_self_temp(dec, (VkImageStencilUsageCreateInfo *)pnext);
6394 }
6395 break;
6396 default:
6397 /* unexpected struct */
6398 pnext = NULL;
6399 vn_cs_decoder_set_fatal(dec);
6400 break;
6401 }
6402
6403 return pnext;
6404 }
6405
6406 static inline void
vn_decode_VkPhysicalDeviceImageFormatInfo2_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceImageFormatInfo2 * val)6407 vn_decode_VkPhysicalDeviceImageFormatInfo2_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceImageFormatInfo2 *val)
6408 {
6409 /* skip val->{sType,pNext} */
6410 vn_decode_VkFormat(dec, &val->format);
6411 vn_decode_VkImageType(dec, &val->type);
6412 vn_decode_VkImageTiling(dec, &val->tiling);
6413 vn_decode_VkFlags(dec, &val->usage);
6414 vn_decode_VkFlags(dec, &val->flags);
6415 }
6416
6417 static inline void
vn_decode_VkPhysicalDeviceImageFormatInfo2_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceImageFormatInfo2 * val)6418 vn_decode_VkPhysicalDeviceImageFormatInfo2_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceImageFormatInfo2 *val)
6419 {
6420 VkStructureType stype;
6421 vn_decode_VkStructureType(dec, &stype);
6422 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2)
6423 vn_cs_decoder_set_fatal(dec);
6424
6425 val->sType = stype;
6426 val->pNext = vn_decode_VkPhysicalDeviceImageFormatInfo2_pnext_temp(dec);
6427 vn_decode_VkPhysicalDeviceImageFormatInfo2_self_temp(dec, val);
6428 }
6429
6430 static inline void
vn_replace_VkPhysicalDeviceImageFormatInfo2_handle_self(VkPhysicalDeviceImageFormatInfo2 * val)6431 vn_replace_VkPhysicalDeviceImageFormatInfo2_handle_self(VkPhysicalDeviceImageFormatInfo2 *val)
6432 {
6433 /* skip val->sType */
6434 /* skip val->pNext */
6435 /* skip val->format */
6436 /* skip val->type */
6437 /* skip val->tiling */
6438 /* skip val->usage */
6439 /* skip val->flags */
6440 }
6441
6442 static inline void
vn_replace_VkPhysicalDeviceImageFormatInfo2_handle(VkPhysicalDeviceImageFormatInfo2 * val)6443 vn_replace_VkPhysicalDeviceImageFormatInfo2_handle(VkPhysicalDeviceImageFormatInfo2 *val)
6444 {
6445 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
6446
6447 do {
6448 switch ((int32_t)pnext->sType) {
6449 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2:
6450 vn_replace_VkPhysicalDeviceImageFormatInfo2_handle_self((VkPhysicalDeviceImageFormatInfo2 *)pnext);
6451 break;
6452 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
6453 vn_replace_VkPhysicalDeviceExternalImageFormatInfo_handle_self((VkPhysicalDeviceExternalImageFormatInfo *)pnext);
6454 break;
6455 case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
6456 vn_replace_VkImageFormatListCreateInfo_handle_self((VkImageFormatListCreateInfo *)pnext);
6457 break;
6458 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
6459 vn_replace_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_handle_self((VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)pnext);
6460 break;
6461 case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
6462 vn_replace_VkImageStencilUsageCreateInfo_handle_self((VkImageStencilUsageCreateInfo *)pnext);
6463 break;
6464 default:
6465 /* ignore unknown/unsupported struct */
6466 break;
6467 }
6468 pnext = pnext->pNext;
6469 } while (pnext);
6470 }
6471
6472 /* struct VkExternalMemoryProperties */
6473
6474 static inline void
vn_encode_VkExternalMemoryProperties(struct vn_cs_encoder * enc,const VkExternalMemoryProperties * val)6475 vn_encode_VkExternalMemoryProperties(struct vn_cs_encoder *enc, const VkExternalMemoryProperties *val)
6476 {
6477 vn_encode_VkFlags(enc, &val->externalMemoryFeatures);
6478 vn_encode_VkFlags(enc, &val->exportFromImportedHandleTypes);
6479 vn_encode_VkFlags(enc, &val->compatibleHandleTypes);
6480 }
6481
6482 static inline void
vn_decode_VkExternalMemoryProperties_partial_temp(struct vn_cs_decoder * dec,VkExternalMemoryProperties * val)6483 vn_decode_VkExternalMemoryProperties_partial_temp(struct vn_cs_decoder *dec, VkExternalMemoryProperties *val)
6484 {
6485 /* skip val->externalMemoryFeatures */
6486 /* skip val->exportFromImportedHandleTypes */
6487 /* skip val->compatibleHandleTypes */
6488 }
6489
6490 /* struct VkExternalImageFormatProperties chain */
6491
6492 static inline void
vn_encode_VkExternalImageFormatProperties_pnext(struct vn_cs_encoder * enc,const void * val)6493 vn_encode_VkExternalImageFormatProperties_pnext(struct vn_cs_encoder *enc, const void *val)
6494 {
6495 /* no known/supported struct */
6496 vn_encode_simple_pointer(enc, NULL);
6497 }
6498
6499 static inline void
vn_encode_VkExternalImageFormatProperties_self(struct vn_cs_encoder * enc,const VkExternalImageFormatProperties * val)6500 vn_encode_VkExternalImageFormatProperties_self(struct vn_cs_encoder *enc, const VkExternalImageFormatProperties *val)
6501 {
6502 /* skip val->{sType,pNext} */
6503 vn_encode_VkExternalMemoryProperties(enc, &val->externalMemoryProperties);
6504 }
6505
6506 static inline void
vn_encode_VkExternalImageFormatProperties(struct vn_cs_encoder * enc,const VkExternalImageFormatProperties * val)6507 vn_encode_VkExternalImageFormatProperties(struct vn_cs_encoder *enc, const VkExternalImageFormatProperties *val)
6508 {
6509 assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
6510 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES });
6511 vn_encode_VkExternalImageFormatProperties_pnext(enc, val->pNext);
6512 vn_encode_VkExternalImageFormatProperties_self(enc, val);
6513 }
6514
6515 static inline void *
vn_decode_VkExternalImageFormatProperties_pnext_partial_temp(struct vn_cs_decoder * dec)6516 vn_decode_VkExternalImageFormatProperties_pnext_partial_temp(struct vn_cs_decoder *dec)
6517 {
6518 /* no known/supported struct */
6519 if (vn_decode_simple_pointer(dec))
6520 vn_cs_decoder_set_fatal(dec);
6521 return NULL;
6522 }
6523
6524 static inline void
vn_decode_VkExternalImageFormatProperties_self_partial_temp(struct vn_cs_decoder * dec,VkExternalImageFormatProperties * val)6525 vn_decode_VkExternalImageFormatProperties_self_partial_temp(struct vn_cs_decoder *dec, VkExternalImageFormatProperties *val)
6526 {
6527 /* skip val->{sType,pNext} */
6528 vn_decode_VkExternalMemoryProperties_partial_temp(dec, &val->externalMemoryProperties);
6529 }
6530
6531 static inline void
vn_decode_VkExternalImageFormatProperties_partial_temp(struct vn_cs_decoder * dec,VkExternalImageFormatProperties * val)6532 vn_decode_VkExternalImageFormatProperties_partial_temp(struct vn_cs_decoder *dec, VkExternalImageFormatProperties *val)
6533 {
6534 VkStructureType stype;
6535 vn_decode_VkStructureType(dec, &stype);
6536 if (stype != VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES)
6537 vn_cs_decoder_set_fatal(dec);
6538
6539 val->sType = stype;
6540 val->pNext = vn_decode_VkExternalImageFormatProperties_pnext_partial_temp(dec);
6541 vn_decode_VkExternalImageFormatProperties_self_partial_temp(dec, val);
6542 }
6543
6544 /* struct VkSamplerYcbcrConversionImageFormatProperties chain */
6545
6546 static inline void
vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext(struct vn_cs_encoder * enc,const void * val)6547 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext(struct vn_cs_encoder *enc, const void *val)
6548 {
6549 /* no known/supported struct */
6550 vn_encode_simple_pointer(enc, NULL);
6551 }
6552
6553 static inline void
vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self(struct vn_cs_encoder * enc,const VkSamplerYcbcrConversionImageFormatProperties * val)6554 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionImageFormatProperties *val)
6555 {
6556 /* skip val->{sType,pNext} */
6557 vn_encode_uint32_t(enc, &val->combinedImageSamplerDescriptorCount);
6558 }
6559
6560 static inline void
vn_encode_VkSamplerYcbcrConversionImageFormatProperties(struct vn_cs_encoder * enc,const VkSamplerYcbcrConversionImageFormatProperties * val)6561 vn_encode_VkSamplerYcbcrConversionImageFormatProperties(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionImageFormatProperties *val)
6562 {
6563 assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
6564 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES });
6565 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext(enc, val->pNext);
6566 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self(enc, val);
6567 }
6568
6569 static inline void *
vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial_temp(struct vn_cs_decoder * dec)6570 vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial_temp(struct vn_cs_decoder *dec)
6571 {
6572 /* no known/supported struct */
6573 if (vn_decode_simple_pointer(dec))
6574 vn_cs_decoder_set_fatal(dec);
6575 return NULL;
6576 }
6577
6578 static inline void
vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self_partial_temp(struct vn_cs_decoder * dec,VkSamplerYcbcrConversionImageFormatProperties * val)6579 vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self_partial_temp(struct vn_cs_decoder *dec, VkSamplerYcbcrConversionImageFormatProperties *val)
6580 {
6581 /* skip val->{sType,pNext} */
6582 /* skip val->combinedImageSamplerDescriptorCount */
6583 }
6584
6585 static inline void
vn_decode_VkSamplerYcbcrConversionImageFormatProperties_partial_temp(struct vn_cs_decoder * dec,VkSamplerYcbcrConversionImageFormatProperties * val)6586 vn_decode_VkSamplerYcbcrConversionImageFormatProperties_partial_temp(struct vn_cs_decoder *dec, VkSamplerYcbcrConversionImageFormatProperties *val)
6587 {
6588 VkStructureType stype;
6589 vn_decode_VkStructureType(dec, &stype);
6590 if (stype != VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES)
6591 vn_cs_decoder_set_fatal(dec);
6592
6593 val->sType = stype;
6594 val->pNext = vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial_temp(dec);
6595 vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self_partial_temp(dec, val);
6596 }
6597
6598 /* struct VkImageFormatProperties2 chain */
6599
6600 static inline void
vn_encode_VkImageFormatProperties2_pnext(struct vn_cs_encoder * enc,const void * val)6601 vn_encode_VkImageFormatProperties2_pnext(struct vn_cs_encoder *enc, const void *val)
6602 {
6603 const VkBaseInStructure *pnext = val;
6604
6605 while (pnext) {
6606 switch ((int32_t)pnext->sType) {
6607 case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
6608 vn_encode_simple_pointer(enc, pnext);
6609 vn_encode_VkStructureType(enc, &pnext->sType);
6610 vn_encode_VkImageFormatProperties2_pnext(enc, pnext->pNext);
6611 vn_encode_VkExternalImageFormatProperties_self(enc, (const VkExternalImageFormatProperties *)pnext);
6612 return;
6613 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
6614 vn_encode_simple_pointer(enc, pnext);
6615 vn_encode_VkStructureType(enc, &pnext->sType);
6616 vn_encode_VkImageFormatProperties2_pnext(enc, pnext->pNext);
6617 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self(enc, (const VkSamplerYcbcrConversionImageFormatProperties *)pnext);
6618 return;
6619 default:
6620 /* ignore unknown/unsupported struct */
6621 break;
6622 }
6623 pnext = pnext->pNext;
6624 }
6625
6626 vn_encode_simple_pointer(enc, NULL);
6627 }
6628
6629 static inline void
vn_encode_VkImageFormatProperties2_self(struct vn_cs_encoder * enc,const VkImageFormatProperties2 * val)6630 vn_encode_VkImageFormatProperties2_self(struct vn_cs_encoder *enc, const VkImageFormatProperties2 *val)
6631 {
6632 /* skip val->{sType,pNext} */
6633 vn_encode_VkImageFormatProperties(enc, &val->imageFormatProperties);
6634 }
6635
6636 static inline void
vn_encode_VkImageFormatProperties2(struct vn_cs_encoder * enc,const VkImageFormatProperties2 * val)6637 vn_encode_VkImageFormatProperties2(struct vn_cs_encoder *enc, const VkImageFormatProperties2 *val)
6638 {
6639 assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2);
6640 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 });
6641 vn_encode_VkImageFormatProperties2_pnext(enc, val->pNext);
6642 vn_encode_VkImageFormatProperties2_self(enc, val);
6643 }
6644
6645 static inline void *
vn_decode_VkImageFormatProperties2_pnext_partial_temp(struct vn_cs_decoder * dec)6646 vn_decode_VkImageFormatProperties2_pnext_partial_temp(struct vn_cs_decoder *dec)
6647 {
6648 VkBaseOutStructure *pnext;
6649 VkStructureType stype;
6650
6651 if (!vn_decode_simple_pointer(dec))
6652 return NULL;
6653
6654 vn_decode_VkStructureType(dec, &stype);
6655 switch ((int32_t)stype) {
6656 case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
6657 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkExternalImageFormatProperties));
6658 if (pnext) {
6659 pnext->sType = stype;
6660 pnext->pNext = vn_decode_VkImageFormatProperties2_pnext_partial_temp(dec);
6661 vn_decode_VkExternalImageFormatProperties_self_partial_temp(dec, (VkExternalImageFormatProperties *)pnext);
6662 }
6663 break;
6664 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
6665 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkSamplerYcbcrConversionImageFormatProperties));
6666 if (pnext) {
6667 pnext->sType = stype;
6668 pnext->pNext = vn_decode_VkImageFormatProperties2_pnext_partial_temp(dec);
6669 vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self_partial_temp(dec, (VkSamplerYcbcrConversionImageFormatProperties *)pnext);
6670 }
6671 break;
6672 default:
6673 /* unexpected struct */
6674 pnext = NULL;
6675 vn_cs_decoder_set_fatal(dec);
6676 break;
6677 }
6678
6679 return pnext;
6680 }
6681
6682 static inline void
vn_decode_VkImageFormatProperties2_self_partial_temp(struct vn_cs_decoder * dec,VkImageFormatProperties2 * val)6683 vn_decode_VkImageFormatProperties2_self_partial_temp(struct vn_cs_decoder *dec, VkImageFormatProperties2 *val)
6684 {
6685 /* skip val->{sType,pNext} */
6686 vn_decode_VkImageFormatProperties_partial_temp(dec, &val->imageFormatProperties);
6687 }
6688
6689 static inline void
vn_decode_VkImageFormatProperties2_partial_temp(struct vn_cs_decoder * dec,VkImageFormatProperties2 * val)6690 vn_decode_VkImageFormatProperties2_partial_temp(struct vn_cs_decoder *dec, VkImageFormatProperties2 *val)
6691 {
6692 VkStructureType stype;
6693 vn_decode_VkStructureType(dec, &stype);
6694 if (stype != VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2)
6695 vn_cs_decoder_set_fatal(dec);
6696
6697 val->sType = stype;
6698 val->pNext = vn_decode_VkImageFormatProperties2_pnext_partial_temp(dec);
6699 vn_decode_VkImageFormatProperties2_self_partial_temp(dec, val);
6700 }
6701
6702 /* struct VkQueueFamilyProperties2 chain */
6703
6704 static inline void
vn_encode_VkQueueFamilyProperties2_pnext(struct vn_cs_encoder * enc,const void * val)6705 vn_encode_VkQueueFamilyProperties2_pnext(struct vn_cs_encoder *enc, const void *val)
6706 {
6707 /* no known/supported struct */
6708 vn_encode_simple_pointer(enc, NULL);
6709 }
6710
6711 static inline void
vn_encode_VkQueueFamilyProperties2_self(struct vn_cs_encoder * enc,const VkQueueFamilyProperties2 * val)6712 vn_encode_VkQueueFamilyProperties2_self(struct vn_cs_encoder *enc, const VkQueueFamilyProperties2 *val)
6713 {
6714 /* skip val->{sType,pNext} */
6715 vn_encode_VkQueueFamilyProperties(enc, &val->queueFamilyProperties);
6716 }
6717
6718 static inline void
vn_encode_VkQueueFamilyProperties2(struct vn_cs_encoder * enc,const VkQueueFamilyProperties2 * val)6719 vn_encode_VkQueueFamilyProperties2(struct vn_cs_encoder *enc, const VkQueueFamilyProperties2 *val)
6720 {
6721 assert(val->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2);
6722 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 });
6723 vn_encode_VkQueueFamilyProperties2_pnext(enc, val->pNext);
6724 vn_encode_VkQueueFamilyProperties2_self(enc, val);
6725 }
6726
6727 static inline void *
vn_decode_VkQueueFamilyProperties2_pnext_partial_temp(struct vn_cs_decoder * dec)6728 vn_decode_VkQueueFamilyProperties2_pnext_partial_temp(struct vn_cs_decoder *dec)
6729 {
6730 /* no known/supported struct */
6731 if (vn_decode_simple_pointer(dec))
6732 vn_cs_decoder_set_fatal(dec);
6733 return NULL;
6734 }
6735
6736 static inline void
vn_decode_VkQueueFamilyProperties2_self_partial_temp(struct vn_cs_decoder * dec,VkQueueFamilyProperties2 * val)6737 vn_decode_VkQueueFamilyProperties2_self_partial_temp(struct vn_cs_decoder *dec, VkQueueFamilyProperties2 *val)
6738 {
6739 /* skip val->{sType,pNext} */
6740 vn_decode_VkQueueFamilyProperties_partial_temp(dec, &val->queueFamilyProperties);
6741 }
6742
6743 static inline void
vn_decode_VkQueueFamilyProperties2_partial_temp(struct vn_cs_decoder * dec,VkQueueFamilyProperties2 * val)6744 vn_decode_VkQueueFamilyProperties2_partial_temp(struct vn_cs_decoder *dec, VkQueueFamilyProperties2 *val)
6745 {
6746 VkStructureType stype;
6747 vn_decode_VkStructureType(dec, &stype);
6748 if (stype != VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2)
6749 vn_cs_decoder_set_fatal(dec);
6750
6751 val->sType = stype;
6752 val->pNext = vn_decode_VkQueueFamilyProperties2_pnext_partial_temp(dec);
6753 vn_decode_VkQueueFamilyProperties2_self_partial_temp(dec, val);
6754 }
6755
6756 /* struct VkPhysicalDeviceMemoryProperties2 chain */
6757
6758 static inline void
vn_encode_VkPhysicalDeviceMemoryProperties2_pnext(struct vn_cs_encoder * enc,const void * val)6759 vn_encode_VkPhysicalDeviceMemoryProperties2_pnext(struct vn_cs_encoder *enc, const void *val)
6760 {
6761 /* no known/supported struct */
6762 vn_encode_simple_pointer(enc, NULL);
6763 }
6764
6765 static inline void
vn_encode_VkPhysicalDeviceMemoryProperties2_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceMemoryProperties2 * val)6766 vn_encode_VkPhysicalDeviceMemoryProperties2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties2 *val)
6767 {
6768 /* skip val->{sType,pNext} */
6769 vn_encode_VkPhysicalDeviceMemoryProperties(enc, &val->memoryProperties);
6770 }
6771
6772 static inline void
vn_encode_VkPhysicalDeviceMemoryProperties2(struct vn_cs_encoder * enc,const VkPhysicalDeviceMemoryProperties2 * val)6773 vn_encode_VkPhysicalDeviceMemoryProperties2(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties2 *val)
6774 {
6775 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2);
6776 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 });
6777 vn_encode_VkPhysicalDeviceMemoryProperties2_pnext(enc, val->pNext);
6778 vn_encode_VkPhysicalDeviceMemoryProperties2_self(enc, val);
6779 }
6780
6781 static inline void *
vn_decode_VkPhysicalDeviceMemoryProperties2_pnext_partial_temp(struct vn_cs_decoder * dec)6782 vn_decode_VkPhysicalDeviceMemoryProperties2_pnext_partial_temp(struct vn_cs_decoder *dec)
6783 {
6784 /* no known/supported struct */
6785 if (vn_decode_simple_pointer(dec))
6786 vn_cs_decoder_set_fatal(dec);
6787 return NULL;
6788 }
6789
6790 static inline void
vn_decode_VkPhysicalDeviceMemoryProperties2_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceMemoryProperties2 * val)6791 vn_decode_VkPhysicalDeviceMemoryProperties2_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties2 *val)
6792 {
6793 /* skip val->{sType,pNext} */
6794 vn_decode_VkPhysicalDeviceMemoryProperties_partial_temp(dec, &val->memoryProperties);
6795 }
6796
6797 static inline void
vn_decode_VkPhysicalDeviceMemoryProperties2_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceMemoryProperties2 * val)6798 vn_decode_VkPhysicalDeviceMemoryProperties2_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties2 *val)
6799 {
6800 VkStructureType stype;
6801 vn_decode_VkStructureType(dec, &stype);
6802 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2)
6803 vn_cs_decoder_set_fatal(dec);
6804
6805 val->sType = stype;
6806 val->pNext = vn_decode_VkPhysicalDeviceMemoryProperties2_pnext_partial_temp(dec);
6807 vn_decode_VkPhysicalDeviceMemoryProperties2_self_partial_temp(dec, val);
6808 }
6809
6810 /* struct VkPhysicalDeviceSparseImageFormatInfo2 chain */
6811
6812 static inline void *
vn_decode_VkPhysicalDeviceSparseImageFormatInfo2_pnext_temp(struct vn_cs_decoder * dec)6813 vn_decode_VkPhysicalDeviceSparseImageFormatInfo2_pnext_temp(struct vn_cs_decoder *dec)
6814 {
6815 /* no known/supported struct */
6816 if (vn_decode_simple_pointer(dec))
6817 vn_cs_decoder_set_fatal(dec);
6818 return NULL;
6819 }
6820
6821 static inline void
vn_decode_VkPhysicalDeviceSparseImageFormatInfo2_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceSparseImageFormatInfo2 * val)6822 vn_decode_VkPhysicalDeviceSparseImageFormatInfo2_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceSparseImageFormatInfo2 *val)
6823 {
6824 /* skip val->{sType,pNext} */
6825 vn_decode_VkFormat(dec, &val->format);
6826 vn_decode_VkImageType(dec, &val->type);
6827 vn_decode_VkSampleCountFlagBits(dec, &val->samples);
6828 vn_decode_VkFlags(dec, &val->usage);
6829 vn_decode_VkImageTiling(dec, &val->tiling);
6830 }
6831
6832 static inline void
vn_decode_VkPhysicalDeviceSparseImageFormatInfo2_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceSparseImageFormatInfo2 * val)6833 vn_decode_VkPhysicalDeviceSparseImageFormatInfo2_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceSparseImageFormatInfo2 *val)
6834 {
6835 VkStructureType stype;
6836 vn_decode_VkStructureType(dec, &stype);
6837 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2)
6838 vn_cs_decoder_set_fatal(dec);
6839
6840 val->sType = stype;
6841 val->pNext = vn_decode_VkPhysicalDeviceSparseImageFormatInfo2_pnext_temp(dec);
6842 vn_decode_VkPhysicalDeviceSparseImageFormatInfo2_self_temp(dec, val);
6843 }
6844
6845 static inline void
vn_replace_VkPhysicalDeviceSparseImageFormatInfo2_handle_self(VkPhysicalDeviceSparseImageFormatInfo2 * val)6846 vn_replace_VkPhysicalDeviceSparseImageFormatInfo2_handle_self(VkPhysicalDeviceSparseImageFormatInfo2 *val)
6847 {
6848 /* skip val->sType */
6849 /* skip val->pNext */
6850 /* skip val->format */
6851 /* skip val->type */
6852 /* skip val->samples */
6853 /* skip val->usage */
6854 /* skip val->tiling */
6855 }
6856
6857 static inline void
vn_replace_VkPhysicalDeviceSparseImageFormatInfo2_handle(VkPhysicalDeviceSparseImageFormatInfo2 * val)6858 vn_replace_VkPhysicalDeviceSparseImageFormatInfo2_handle(VkPhysicalDeviceSparseImageFormatInfo2 *val)
6859 {
6860 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
6861
6862 do {
6863 switch ((int32_t)pnext->sType) {
6864 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2:
6865 vn_replace_VkPhysicalDeviceSparseImageFormatInfo2_handle_self((VkPhysicalDeviceSparseImageFormatInfo2 *)pnext);
6866 break;
6867 default:
6868 /* ignore unknown/unsupported struct */
6869 break;
6870 }
6871 pnext = pnext->pNext;
6872 } while (pnext);
6873 }
6874
6875 /* struct VkSparseImageFormatProperties2 chain */
6876
6877 static inline void
vn_encode_VkSparseImageFormatProperties2_pnext(struct vn_cs_encoder * enc,const void * val)6878 vn_encode_VkSparseImageFormatProperties2_pnext(struct vn_cs_encoder *enc, const void *val)
6879 {
6880 /* no known/supported struct */
6881 vn_encode_simple_pointer(enc, NULL);
6882 }
6883
6884 static inline void
vn_encode_VkSparseImageFormatProperties2_self(struct vn_cs_encoder * enc,const VkSparseImageFormatProperties2 * val)6885 vn_encode_VkSparseImageFormatProperties2_self(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties2 *val)
6886 {
6887 /* skip val->{sType,pNext} */
6888 vn_encode_VkSparseImageFormatProperties(enc, &val->properties);
6889 }
6890
6891 static inline void
vn_encode_VkSparseImageFormatProperties2(struct vn_cs_encoder * enc,const VkSparseImageFormatProperties2 * val)6892 vn_encode_VkSparseImageFormatProperties2(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties2 *val)
6893 {
6894 assert(val->sType == VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2);
6895 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 });
6896 vn_encode_VkSparseImageFormatProperties2_pnext(enc, val->pNext);
6897 vn_encode_VkSparseImageFormatProperties2_self(enc, val);
6898 }
6899
6900 static inline void *
vn_decode_VkSparseImageFormatProperties2_pnext_partial_temp(struct vn_cs_decoder * dec)6901 vn_decode_VkSparseImageFormatProperties2_pnext_partial_temp(struct vn_cs_decoder *dec)
6902 {
6903 /* no known/supported struct */
6904 if (vn_decode_simple_pointer(dec))
6905 vn_cs_decoder_set_fatal(dec);
6906 return NULL;
6907 }
6908
6909 static inline void
vn_decode_VkSparseImageFormatProperties2_self_partial_temp(struct vn_cs_decoder * dec,VkSparseImageFormatProperties2 * val)6910 vn_decode_VkSparseImageFormatProperties2_self_partial_temp(struct vn_cs_decoder *dec, VkSparseImageFormatProperties2 *val)
6911 {
6912 /* skip val->{sType,pNext} */
6913 vn_decode_VkSparseImageFormatProperties_partial_temp(dec, &val->properties);
6914 }
6915
6916 static inline void
vn_decode_VkSparseImageFormatProperties2_partial_temp(struct vn_cs_decoder * dec,VkSparseImageFormatProperties2 * val)6917 vn_decode_VkSparseImageFormatProperties2_partial_temp(struct vn_cs_decoder *dec, VkSparseImageFormatProperties2 *val)
6918 {
6919 VkStructureType stype;
6920 vn_decode_VkStructureType(dec, &stype);
6921 if (stype != VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2)
6922 vn_cs_decoder_set_fatal(dec);
6923
6924 val->sType = stype;
6925 val->pNext = vn_decode_VkSparseImageFormatProperties2_pnext_partial_temp(dec);
6926 vn_decode_VkSparseImageFormatProperties2_self_partial_temp(dec, val);
6927 }
6928
6929 /* struct VkPhysicalDeviceExternalBufferInfo chain */
6930
6931 static inline void *
vn_decode_VkPhysicalDeviceExternalBufferInfo_pnext_temp(struct vn_cs_decoder * dec)6932 vn_decode_VkPhysicalDeviceExternalBufferInfo_pnext_temp(struct vn_cs_decoder *dec)
6933 {
6934 /* no known/supported struct */
6935 if (vn_decode_simple_pointer(dec))
6936 vn_cs_decoder_set_fatal(dec);
6937 return NULL;
6938 }
6939
6940 static inline void
vn_decode_VkPhysicalDeviceExternalBufferInfo_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceExternalBufferInfo * val)6941 vn_decode_VkPhysicalDeviceExternalBufferInfo_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceExternalBufferInfo *val)
6942 {
6943 /* skip val->{sType,pNext} */
6944 vn_decode_VkFlags(dec, &val->flags);
6945 vn_decode_VkFlags(dec, &val->usage);
6946 vn_decode_VkExternalMemoryHandleTypeFlagBits(dec, &val->handleType);
6947 }
6948
6949 static inline void
vn_decode_VkPhysicalDeviceExternalBufferInfo_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceExternalBufferInfo * val)6950 vn_decode_VkPhysicalDeviceExternalBufferInfo_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceExternalBufferInfo *val)
6951 {
6952 VkStructureType stype;
6953 vn_decode_VkStructureType(dec, &stype);
6954 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO)
6955 vn_cs_decoder_set_fatal(dec);
6956
6957 val->sType = stype;
6958 val->pNext = vn_decode_VkPhysicalDeviceExternalBufferInfo_pnext_temp(dec);
6959 vn_decode_VkPhysicalDeviceExternalBufferInfo_self_temp(dec, val);
6960 }
6961
6962 static inline void
vn_replace_VkPhysicalDeviceExternalBufferInfo_handle_self(VkPhysicalDeviceExternalBufferInfo * val)6963 vn_replace_VkPhysicalDeviceExternalBufferInfo_handle_self(VkPhysicalDeviceExternalBufferInfo *val)
6964 {
6965 /* skip val->sType */
6966 /* skip val->pNext */
6967 /* skip val->flags */
6968 /* skip val->usage */
6969 /* skip val->handleType */
6970 }
6971
6972 static inline void
vn_replace_VkPhysicalDeviceExternalBufferInfo_handle(VkPhysicalDeviceExternalBufferInfo * val)6973 vn_replace_VkPhysicalDeviceExternalBufferInfo_handle(VkPhysicalDeviceExternalBufferInfo *val)
6974 {
6975 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
6976
6977 do {
6978 switch ((int32_t)pnext->sType) {
6979 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO:
6980 vn_replace_VkPhysicalDeviceExternalBufferInfo_handle_self((VkPhysicalDeviceExternalBufferInfo *)pnext);
6981 break;
6982 default:
6983 /* ignore unknown/unsupported struct */
6984 break;
6985 }
6986 pnext = pnext->pNext;
6987 } while (pnext);
6988 }
6989
6990 /* struct VkExternalBufferProperties chain */
6991
6992 static inline void
vn_encode_VkExternalBufferProperties_pnext(struct vn_cs_encoder * enc,const void * val)6993 vn_encode_VkExternalBufferProperties_pnext(struct vn_cs_encoder *enc, const void *val)
6994 {
6995 /* no known/supported struct */
6996 vn_encode_simple_pointer(enc, NULL);
6997 }
6998
6999 static inline void
vn_encode_VkExternalBufferProperties_self(struct vn_cs_encoder * enc,const VkExternalBufferProperties * val)7000 vn_encode_VkExternalBufferProperties_self(struct vn_cs_encoder *enc, const VkExternalBufferProperties *val)
7001 {
7002 /* skip val->{sType,pNext} */
7003 vn_encode_VkExternalMemoryProperties(enc, &val->externalMemoryProperties);
7004 }
7005
7006 static inline void
vn_encode_VkExternalBufferProperties(struct vn_cs_encoder * enc,const VkExternalBufferProperties * val)7007 vn_encode_VkExternalBufferProperties(struct vn_cs_encoder *enc, const VkExternalBufferProperties *val)
7008 {
7009 assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES);
7010 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES });
7011 vn_encode_VkExternalBufferProperties_pnext(enc, val->pNext);
7012 vn_encode_VkExternalBufferProperties_self(enc, val);
7013 }
7014
7015 static inline void *
vn_decode_VkExternalBufferProperties_pnext_partial_temp(struct vn_cs_decoder * dec)7016 vn_decode_VkExternalBufferProperties_pnext_partial_temp(struct vn_cs_decoder *dec)
7017 {
7018 /* no known/supported struct */
7019 if (vn_decode_simple_pointer(dec))
7020 vn_cs_decoder_set_fatal(dec);
7021 return NULL;
7022 }
7023
7024 static inline void
vn_decode_VkExternalBufferProperties_self_partial_temp(struct vn_cs_decoder * dec,VkExternalBufferProperties * val)7025 vn_decode_VkExternalBufferProperties_self_partial_temp(struct vn_cs_decoder *dec, VkExternalBufferProperties *val)
7026 {
7027 /* skip val->{sType,pNext} */
7028 vn_decode_VkExternalMemoryProperties_partial_temp(dec, &val->externalMemoryProperties);
7029 }
7030
7031 static inline void
vn_decode_VkExternalBufferProperties_partial_temp(struct vn_cs_decoder * dec,VkExternalBufferProperties * val)7032 vn_decode_VkExternalBufferProperties_partial_temp(struct vn_cs_decoder *dec, VkExternalBufferProperties *val)
7033 {
7034 VkStructureType stype;
7035 vn_decode_VkStructureType(dec, &stype);
7036 if (stype != VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES)
7037 vn_cs_decoder_set_fatal(dec);
7038
7039 val->sType = stype;
7040 val->pNext = vn_decode_VkExternalBufferProperties_pnext_partial_temp(dec);
7041 vn_decode_VkExternalBufferProperties_self_partial_temp(dec, val);
7042 }
7043
7044 /* struct VkPhysicalDeviceExternalSemaphoreInfo chain */
7045
7046 static inline void *
vn_decode_VkPhysicalDeviceExternalSemaphoreInfo_pnext_temp(struct vn_cs_decoder * dec)7047 vn_decode_VkPhysicalDeviceExternalSemaphoreInfo_pnext_temp(struct vn_cs_decoder *dec)
7048 {
7049 VkBaseOutStructure *pnext;
7050 VkStructureType stype;
7051
7052 if (!vn_decode_simple_pointer(dec))
7053 return NULL;
7054
7055 vn_decode_VkStructureType(dec, &stype);
7056 switch ((int32_t)stype) {
7057 case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
7058 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkSemaphoreTypeCreateInfo));
7059 if (pnext) {
7060 pnext->sType = stype;
7061 pnext->pNext = vn_decode_VkPhysicalDeviceExternalSemaphoreInfo_pnext_temp(dec);
7062 vn_decode_VkSemaphoreTypeCreateInfo_self_temp(dec, (VkSemaphoreTypeCreateInfo *)pnext);
7063 }
7064 break;
7065 default:
7066 /* unexpected struct */
7067 pnext = NULL;
7068 vn_cs_decoder_set_fatal(dec);
7069 break;
7070 }
7071
7072 return pnext;
7073 }
7074
7075 static inline void
vn_decode_VkPhysicalDeviceExternalSemaphoreInfo_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceExternalSemaphoreInfo * val)7076 vn_decode_VkPhysicalDeviceExternalSemaphoreInfo_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceExternalSemaphoreInfo *val)
7077 {
7078 /* skip val->{sType,pNext} */
7079 vn_decode_VkExternalSemaphoreHandleTypeFlagBits(dec, &val->handleType);
7080 }
7081
7082 static inline void
vn_decode_VkPhysicalDeviceExternalSemaphoreInfo_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceExternalSemaphoreInfo * val)7083 vn_decode_VkPhysicalDeviceExternalSemaphoreInfo_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceExternalSemaphoreInfo *val)
7084 {
7085 VkStructureType stype;
7086 vn_decode_VkStructureType(dec, &stype);
7087 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO)
7088 vn_cs_decoder_set_fatal(dec);
7089
7090 val->sType = stype;
7091 val->pNext = vn_decode_VkPhysicalDeviceExternalSemaphoreInfo_pnext_temp(dec);
7092 vn_decode_VkPhysicalDeviceExternalSemaphoreInfo_self_temp(dec, val);
7093 }
7094
7095 static inline void
vn_replace_VkPhysicalDeviceExternalSemaphoreInfo_handle_self(VkPhysicalDeviceExternalSemaphoreInfo * val)7096 vn_replace_VkPhysicalDeviceExternalSemaphoreInfo_handle_self(VkPhysicalDeviceExternalSemaphoreInfo *val)
7097 {
7098 /* skip val->sType */
7099 /* skip val->pNext */
7100 /* skip val->handleType */
7101 }
7102
7103 static inline void
vn_replace_VkPhysicalDeviceExternalSemaphoreInfo_handle(VkPhysicalDeviceExternalSemaphoreInfo * val)7104 vn_replace_VkPhysicalDeviceExternalSemaphoreInfo_handle(VkPhysicalDeviceExternalSemaphoreInfo *val)
7105 {
7106 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
7107
7108 do {
7109 switch ((int32_t)pnext->sType) {
7110 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO:
7111 vn_replace_VkPhysicalDeviceExternalSemaphoreInfo_handle_self((VkPhysicalDeviceExternalSemaphoreInfo *)pnext);
7112 break;
7113 case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
7114 vn_replace_VkSemaphoreTypeCreateInfo_handle_self((VkSemaphoreTypeCreateInfo *)pnext);
7115 break;
7116 default:
7117 /* ignore unknown/unsupported struct */
7118 break;
7119 }
7120 pnext = pnext->pNext;
7121 } while (pnext);
7122 }
7123
7124 /* struct VkExternalSemaphoreProperties chain */
7125
7126 static inline void
vn_encode_VkExternalSemaphoreProperties_pnext(struct vn_cs_encoder * enc,const void * val)7127 vn_encode_VkExternalSemaphoreProperties_pnext(struct vn_cs_encoder *enc, const void *val)
7128 {
7129 /* no known/supported struct */
7130 vn_encode_simple_pointer(enc, NULL);
7131 }
7132
7133 static inline void
vn_encode_VkExternalSemaphoreProperties_self(struct vn_cs_encoder * enc,const VkExternalSemaphoreProperties * val)7134 vn_encode_VkExternalSemaphoreProperties_self(struct vn_cs_encoder *enc, const VkExternalSemaphoreProperties *val)
7135 {
7136 /* skip val->{sType,pNext} */
7137 vn_encode_VkFlags(enc, &val->exportFromImportedHandleTypes);
7138 vn_encode_VkFlags(enc, &val->compatibleHandleTypes);
7139 vn_encode_VkFlags(enc, &val->externalSemaphoreFeatures);
7140 }
7141
7142 static inline void
vn_encode_VkExternalSemaphoreProperties(struct vn_cs_encoder * enc,const VkExternalSemaphoreProperties * val)7143 vn_encode_VkExternalSemaphoreProperties(struct vn_cs_encoder *enc, const VkExternalSemaphoreProperties *val)
7144 {
7145 assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES);
7146 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES });
7147 vn_encode_VkExternalSemaphoreProperties_pnext(enc, val->pNext);
7148 vn_encode_VkExternalSemaphoreProperties_self(enc, val);
7149 }
7150
7151 static inline void *
vn_decode_VkExternalSemaphoreProperties_pnext_partial_temp(struct vn_cs_decoder * dec)7152 vn_decode_VkExternalSemaphoreProperties_pnext_partial_temp(struct vn_cs_decoder *dec)
7153 {
7154 /* no known/supported struct */
7155 if (vn_decode_simple_pointer(dec))
7156 vn_cs_decoder_set_fatal(dec);
7157 return NULL;
7158 }
7159
7160 static inline void
vn_decode_VkExternalSemaphoreProperties_self_partial_temp(struct vn_cs_decoder * dec,VkExternalSemaphoreProperties * val)7161 vn_decode_VkExternalSemaphoreProperties_self_partial_temp(struct vn_cs_decoder *dec, VkExternalSemaphoreProperties *val)
7162 {
7163 /* skip val->{sType,pNext} */
7164 /* skip val->exportFromImportedHandleTypes */
7165 /* skip val->compatibleHandleTypes */
7166 /* skip val->externalSemaphoreFeatures */
7167 }
7168
7169 static inline void
vn_decode_VkExternalSemaphoreProperties_partial_temp(struct vn_cs_decoder * dec,VkExternalSemaphoreProperties * val)7170 vn_decode_VkExternalSemaphoreProperties_partial_temp(struct vn_cs_decoder *dec, VkExternalSemaphoreProperties *val)
7171 {
7172 VkStructureType stype;
7173 vn_decode_VkStructureType(dec, &stype);
7174 if (stype != VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES)
7175 vn_cs_decoder_set_fatal(dec);
7176
7177 val->sType = stype;
7178 val->pNext = vn_decode_VkExternalSemaphoreProperties_pnext_partial_temp(dec);
7179 vn_decode_VkExternalSemaphoreProperties_self_partial_temp(dec, val);
7180 }
7181
7182 /* struct VkPhysicalDeviceExternalFenceInfo chain */
7183
7184 static inline void *
vn_decode_VkPhysicalDeviceExternalFenceInfo_pnext_temp(struct vn_cs_decoder * dec)7185 vn_decode_VkPhysicalDeviceExternalFenceInfo_pnext_temp(struct vn_cs_decoder *dec)
7186 {
7187 /* no known/supported struct */
7188 if (vn_decode_simple_pointer(dec))
7189 vn_cs_decoder_set_fatal(dec);
7190 return NULL;
7191 }
7192
7193 static inline void
vn_decode_VkPhysicalDeviceExternalFenceInfo_self_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceExternalFenceInfo * val)7194 vn_decode_VkPhysicalDeviceExternalFenceInfo_self_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceExternalFenceInfo *val)
7195 {
7196 /* skip val->{sType,pNext} */
7197 vn_decode_VkExternalFenceHandleTypeFlagBits(dec, &val->handleType);
7198 }
7199
7200 static inline void
vn_decode_VkPhysicalDeviceExternalFenceInfo_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceExternalFenceInfo * val)7201 vn_decode_VkPhysicalDeviceExternalFenceInfo_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceExternalFenceInfo *val)
7202 {
7203 VkStructureType stype;
7204 vn_decode_VkStructureType(dec, &stype);
7205 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO)
7206 vn_cs_decoder_set_fatal(dec);
7207
7208 val->sType = stype;
7209 val->pNext = vn_decode_VkPhysicalDeviceExternalFenceInfo_pnext_temp(dec);
7210 vn_decode_VkPhysicalDeviceExternalFenceInfo_self_temp(dec, val);
7211 }
7212
7213 static inline void
vn_replace_VkPhysicalDeviceExternalFenceInfo_handle_self(VkPhysicalDeviceExternalFenceInfo * val)7214 vn_replace_VkPhysicalDeviceExternalFenceInfo_handle_self(VkPhysicalDeviceExternalFenceInfo *val)
7215 {
7216 /* skip val->sType */
7217 /* skip val->pNext */
7218 /* skip val->handleType */
7219 }
7220
7221 static inline void
vn_replace_VkPhysicalDeviceExternalFenceInfo_handle(VkPhysicalDeviceExternalFenceInfo * val)7222 vn_replace_VkPhysicalDeviceExternalFenceInfo_handle(VkPhysicalDeviceExternalFenceInfo *val)
7223 {
7224 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
7225
7226 do {
7227 switch ((int32_t)pnext->sType) {
7228 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO:
7229 vn_replace_VkPhysicalDeviceExternalFenceInfo_handle_self((VkPhysicalDeviceExternalFenceInfo *)pnext);
7230 break;
7231 default:
7232 /* ignore unknown/unsupported struct */
7233 break;
7234 }
7235 pnext = pnext->pNext;
7236 } while (pnext);
7237 }
7238
7239 /* struct VkExternalFenceProperties chain */
7240
7241 static inline void
vn_encode_VkExternalFenceProperties_pnext(struct vn_cs_encoder * enc,const void * val)7242 vn_encode_VkExternalFenceProperties_pnext(struct vn_cs_encoder *enc, const void *val)
7243 {
7244 /* no known/supported struct */
7245 vn_encode_simple_pointer(enc, NULL);
7246 }
7247
7248 static inline void
vn_encode_VkExternalFenceProperties_self(struct vn_cs_encoder * enc,const VkExternalFenceProperties * val)7249 vn_encode_VkExternalFenceProperties_self(struct vn_cs_encoder *enc, const VkExternalFenceProperties *val)
7250 {
7251 /* skip val->{sType,pNext} */
7252 vn_encode_VkFlags(enc, &val->exportFromImportedHandleTypes);
7253 vn_encode_VkFlags(enc, &val->compatibleHandleTypes);
7254 vn_encode_VkFlags(enc, &val->externalFenceFeatures);
7255 }
7256
7257 static inline void
vn_encode_VkExternalFenceProperties(struct vn_cs_encoder * enc,const VkExternalFenceProperties * val)7258 vn_encode_VkExternalFenceProperties(struct vn_cs_encoder *enc, const VkExternalFenceProperties *val)
7259 {
7260 assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES);
7261 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES });
7262 vn_encode_VkExternalFenceProperties_pnext(enc, val->pNext);
7263 vn_encode_VkExternalFenceProperties_self(enc, val);
7264 }
7265
7266 static inline void *
vn_decode_VkExternalFenceProperties_pnext_partial_temp(struct vn_cs_decoder * dec)7267 vn_decode_VkExternalFenceProperties_pnext_partial_temp(struct vn_cs_decoder *dec)
7268 {
7269 /* no known/supported struct */
7270 if (vn_decode_simple_pointer(dec))
7271 vn_cs_decoder_set_fatal(dec);
7272 return NULL;
7273 }
7274
7275 static inline void
vn_decode_VkExternalFenceProperties_self_partial_temp(struct vn_cs_decoder * dec,VkExternalFenceProperties * val)7276 vn_decode_VkExternalFenceProperties_self_partial_temp(struct vn_cs_decoder *dec, VkExternalFenceProperties *val)
7277 {
7278 /* skip val->{sType,pNext} */
7279 /* skip val->exportFromImportedHandleTypes */
7280 /* skip val->compatibleHandleTypes */
7281 /* skip val->externalFenceFeatures */
7282 }
7283
7284 static inline void
vn_decode_VkExternalFenceProperties_partial_temp(struct vn_cs_decoder * dec,VkExternalFenceProperties * val)7285 vn_decode_VkExternalFenceProperties_partial_temp(struct vn_cs_decoder *dec, VkExternalFenceProperties *val)
7286 {
7287 VkStructureType stype;
7288 vn_decode_VkStructureType(dec, &stype);
7289 if (stype != VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES)
7290 vn_cs_decoder_set_fatal(dec);
7291
7292 val->sType = stype;
7293 val->pNext = vn_decode_VkExternalFenceProperties_pnext_partial_temp(dec);
7294 vn_decode_VkExternalFenceProperties_self_partial_temp(dec, val);
7295 }
7296
7297 /* struct VkPhysicalDeviceGroupProperties chain */
7298
7299 static inline void
vn_encode_VkPhysicalDeviceGroupProperties_pnext(struct vn_cs_encoder * enc,const void * val)7300 vn_encode_VkPhysicalDeviceGroupProperties_pnext(struct vn_cs_encoder *enc, const void *val)
7301 {
7302 /* no known/supported struct */
7303 vn_encode_simple_pointer(enc, NULL);
7304 }
7305
7306 static inline void
vn_encode_VkPhysicalDeviceGroupProperties_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceGroupProperties * val)7307 vn_encode_VkPhysicalDeviceGroupProperties_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceGroupProperties *val)
7308 {
7309 /* skip val->{sType,pNext} */
7310 vn_encode_uint32_t(enc, &val->physicalDeviceCount);
7311 vn_encode_array_size(enc, VK_MAX_DEVICE_GROUP_SIZE);
7312 for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
7313 vn_encode_VkPhysicalDevice(enc, &val->physicalDevices[i]);
7314 vn_encode_VkBool32(enc, &val->subsetAllocation);
7315 }
7316
7317 static inline void
vn_encode_VkPhysicalDeviceGroupProperties(struct vn_cs_encoder * enc,const VkPhysicalDeviceGroupProperties * val)7318 vn_encode_VkPhysicalDeviceGroupProperties(struct vn_cs_encoder *enc, const VkPhysicalDeviceGroupProperties *val)
7319 {
7320 assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES);
7321 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES });
7322 vn_encode_VkPhysicalDeviceGroupProperties_pnext(enc, val->pNext);
7323 vn_encode_VkPhysicalDeviceGroupProperties_self(enc, val);
7324 }
7325
7326 static inline void *
vn_decode_VkPhysicalDeviceGroupProperties_pnext_partial_temp(struct vn_cs_decoder * dec)7327 vn_decode_VkPhysicalDeviceGroupProperties_pnext_partial_temp(struct vn_cs_decoder *dec)
7328 {
7329 /* no known/supported struct */
7330 if (vn_decode_simple_pointer(dec))
7331 vn_cs_decoder_set_fatal(dec);
7332 return NULL;
7333 }
7334
7335 static inline void
vn_decode_VkPhysicalDeviceGroupProperties_self_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceGroupProperties * val)7336 vn_decode_VkPhysicalDeviceGroupProperties_self_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceGroupProperties *val)
7337 {
7338 /* skip val->{sType,pNext} */
7339 /* skip val->physicalDeviceCount */
7340 {
7341 const uint32_t iter_count = vn_decode_array_size(dec, VK_MAX_DEVICE_GROUP_SIZE);
7342 for (uint32_t i = 0; i < iter_count; i++)
7343 vn_decode_VkPhysicalDevice_temp(dec, &val->physicalDevices[i]);
7344 }
7345 /* skip val->subsetAllocation */
7346 }
7347
7348 static inline void
vn_decode_VkPhysicalDeviceGroupProperties_partial_temp(struct vn_cs_decoder * dec,VkPhysicalDeviceGroupProperties * val)7349 vn_decode_VkPhysicalDeviceGroupProperties_partial_temp(struct vn_cs_decoder *dec, VkPhysicalDeviceGroupProperties *val)
7350 {
7351 VkStructureType stype;
7352 vn_decode_VkStructureType(dec, &stype);
7353 if (stype != VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES)
7354 vn_cs_decoder_set_fatal(dec);
7355
7356 val->sType = stype;
7357 val->pNext = vn_decode_VkPhysicalDeviceGroupProperties_pnext_partial_temp(dec);
7358 vn_decode_VkPhysicalDeviceGroupProperties_self_partial_temp(dec, val);
7359 }
7360
7361 /* struct VkDeviceQueueInfo2 chain */
7362
7363 static inline void *
vn_decode_VkDeviceQueueInfo2_pnext_temp(struct vn_cs_decoder * dec)7364 vn_decode_VkDeviceQueueInfo2_pnext_temp(struct vn_cs_decoder *dec)
7365 {
7366 /* no known/supported struct */
7367 if (vn_decode_simple_pointer(dec))
7368 vn_cs_decoder_set_fatal(dec);
7369 return NULL;
7370 }
7371
7372 static inline void
vn_decode_VkDeviceQueueInfo2_self_temp(struct vn_cs_decoder * dec,VkDeviceQueueInfo2 * val)7373 vn_decode_VkDeviceQueueInfo2_self_temp(struct vn_cs_decoder *dec, VkDeviceQueueInfo2 *val)
7374 {
7375 /* skip val->{sType,pNext} */
7376 vn_decode_VkFlags(dec, &val->flags);
7377 vn_decode_uint32_t(dec, &val->queueFamilyIndex);
7378 vn_decode_uint32_t(dec, &val->queueIndex);
7379 }
7380
7381 static inline void
vn_decode_VkDeviceQueueInfo2_temp(struct vn_cs_decoder * dec,VkDeviceQueueInfo2 * val)7382 vn_decode_VkDeviceQueueInfo2_temp(struct vn_cs_decoder *dec, VkDeviceQueueInfo2 *val)
7383 {
7384 VkStructureType stype;
7385 vn_decode_VkStructureType(dec, &stype);
7386 if (stype != VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2)
7387 vn_cs_decoder_set_fatal(dec);
7388
7389 val->sType = stype;
7390 val->pNext = vn_decode_VkDeviceQueueInfo2_pnext_temp(dec);
7391 vn_decode_VkDeviceQueueInfo2_self_temp(dec, val);
7392 }
7393
7394 static inline void
vn_replace_VkDeviceQueueInfo2_handle_self(VkDeviceQueueInfo2 * val)7395 vn_replace_VkDeviceQueueInfo2_handle_self(VkDeviceQueueInfo2 *val)
7396 {
7397 /* skip val->sType */
7398 /* skip val->pNext */
7399 /* skip val->flags */
7400 /* skip val->queueFamilyIndex */
7401 /* skip val->queueIndex */
7402 }
7403
7404 static inline void
vn_replace_VkDeviceQueueInfo2_handle(VkDeviceQueueInfo2 * val)7405 vn_replace_VkDeviceQueueInfo2_handle(VkDeviceQueueInfo2 *val)
7406 {
7407 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
7408
7409 do {
7410 switch ((int32_t)pnext->sType) {
7411 case VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2:
7412 vn_replace_VkDeviceQueueInfo2_handle_self((VkDeviceQueueInfo2 *)pnext);
7413 break;
7414 default:
7415 /* ignore unknown/unsupported struct */
7416 break;
7417 }
7418 pnext = pnext->pNext;
7419 } while (pnext);
7420 }
7421
vn_decode_vkEnumeratePhysicalDevices_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkEnumeratePhysicalDevices * args)7422 static inline void vn_decode_vkEnumeratePhysicalDevices_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkEnumeratePhysicalDevices *args)
7423 {
7424 vn_decode_VkInstance_lookup(dec, &args->instance);
7425 if (vn_decode_simple_pointer(dec)) {
7426 args->pPhysicalDeviceCount = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pPhysicalDeviceCount));
7427 if (!args->pPhysicalDeviceCount) return;
7428 vn_decode_uint32_t(dec, args->pPhysicalDeviceCount);
7429 } else {
7430 args->pPhysicalDeviceCount = NULL;
7431 vn_cs_decoder_set_fatal(dec);
7432 }
7433 if (vn_peek_array_size(dec)) {
7434 const uint32_t iter_count = vn_decode_array_size(dec, (args->pPhysicalDeviceCount ? *args->pPhysicalDeviceCount : 0));
7435 args->pPhysicalDevices = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pPhysicalDevices) * iter_count);
7436 if (!args->pPhysicalDevices) return;
7437 for (uint32_t i = 0; i < iter_count; i++)
7438 vn_decode_VkPhysicalDevice_temp(dec, &args->pPhysicalDevices[i]);
7439 } else {
7440 vn_decode_array_size_unchecked(dec);
7441 args->pPhysicalDevices = NULL;
7442 }
7443 }
7444
vn_replace_vkEnumeratePhysicalDevices_args_handle(struct vn_command_vkEnumeratePhysicalDevices * args)7445 static inline void vn_replace_vkEnumeratePhysicalDevices_args_handle(struct vn_command_vkEnumeratePhysicalDevices *args)
7446 {
7447 vn_replace_VkInstance_handle(&args->instance);
7448 /* skip args->pPhysicalDeviceCount */
7449 /* skip args->pPhysicalDevices */
7450 }
7451
vn_encode_vkEnumeratePhysicalDevices_reply(struct vn_cs_encoder * enc,const struct vn_command_vkEnumeratePhysicalDevices * args)7452 static inline void vn_encode_vkEnumeratePhysicalDevices_reply(struct vn_cs_encoder *enc, const struct vn_command_vkEnumeratePhysicalDevices *args)
7453 {
7454 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT});
7455
7456 vn_encode_VkResult(enc, &args->ret);
7457 /* skip args->instance */
7458 if (vn_encode_simple_pointer(enc, args->pPhysicalDeviceCount))
7459 vn_encode_uint32_t(enc, args->pPhysicalDeviceCount);
7460 if (args->pPhysicalDevices) {
7461 vn_encode_array_size(enc, (args->pPhysicalDeviceCount ? *args->pPhysicalDeviceCount : 0));
7462 for (uint32_t i = 0; i < (args->pPhysicalDeviceCount ? *args->pPhysicalDeviceCount : 0); i++)
7463 vn_encode_VkPhysicalDevice(enc, &args->pPhysicalDevices[i]);
7464 } else {
7465 vn_encode_array_size(enc, 0);
7466 }
7467 }
7468
vn_decode_vkGetPhysicalDeviceProperties_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetPhysicalDeviceProperties * args)7469 static inline void vn_decode_vkGetPhysicalDeviceProperties_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetPhysicalDeviceProperties *args)
7470 {
7471 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
7472 if (vn_decode_simple_pointer(dec)) {
7473 args->pProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pProperties));
7474 if (!args->pProperties) return;
7475 vn_decode_VkPhysicalDeviceProperties_partial_temp(dec, args->pProperties);
7476 } else {
7477 args->pProperties = NULL;
7478 vn_cs_decoder_set_fatal(dec);
7479 }
7480 }
7481
vn_replace_vkGetPhysicalDeviceProperties_args_handle(struct vn_command_vkGetPhysicalDeviceProperties * args)7482 static inline void vn_replace_vkGetPhysicalDeviceProperties_args_handle(struct vn_command_vkGetPhysicalDeviceProperties *args)
7483 {
7484 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
7485 /* skip args->pProperties */
7486 }
7487
vn_encode_vkGetPhysicalDeviceProperties_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetPhysicalDeviceProperties * args)7488 static inline void vn_encode_vkGetPhysicalDeviceProperties_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetPhysicalDeviceProperties *args)
7489 {
7490 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT});
7491
7492 /* skip args->physicalDevice */
7493 if (vn_encode_simple_pointer(enc, args->pProperties))
7494 vn_encode_VkPhysicalDeviceProperties(enc, args->pProperties);
7495 }
7496
vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetPhysicalDeviceQueueFamilyProperties * args)7497 static inline void vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetPhysicalDeviceQueueFamilyProperties *args)
7498 {
7499 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
7500 if (vn_decode_simple_pointer(dec)) {
7501 args->pQueueFamilyPropertyCount = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pQueueFamilyPropertyCount));
7502 if (!args->pQueueFamilyPropertyCount) return;
7503 vn_decode_uint32_t(dec, args->pQueueFamilyPropertyCount);
7504 } else {
7505 args->pQueueFamilyPropertyCount = NULL;
7506 vn_cs_decoder_set_fatal(dec);
7507 }
7508 if (vn_peek_array_size(dec)) {
7509 const uint32_t iter_count = vn_decode_array_size(dec, (args->pQueueFamilyPropertyCount ? *args->pQueueFamilyPropertyCount : 0));
7510 args->pQueueFamilyProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pQueueFamilyProperties) * iter_count);
7511 if (!args->pQueueFamilyProperties) return;
7512 for (uint32_t i = 0; i < iter_count; i++)
7513 vn_decode_VkQueueFamilyProperties_partial_temp(dec, &args->pQueueFamilyProperties[i]);
7514 } else {
7515 vn_decode_array_size_unchecked(dec);
7516 args->pQueueFamilyProperties = NULL;
7517 }
7518 }
7519
vn_replace_vkGetPhysicalDeviceQueueFamilyProperties_args_handle(struct vn_command_vkGetPhysicalDeviceQueueFamilyProperties * args)7520 static inline void vn_replace_vkGetPhysicalDeviceQueueFamilyProperties_args_handle(struct vn_command_vkGetPhysicalDeviceQueueFamilyProperties *args)
7521 {
7522 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
7523 /* skip args->pQueueFamilyPropertyCount */
7524 /* skip args->pQueueFamilyProperties */
7525 }
7526
vn_encode_vkGetPhysicalDeviceQueueFamilyProperties_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetPhysicalDeviceQueueFamilyProperties * args)7527 static inline void vn_encode_vkGetPhysicalDeviceQueueFamilyProperties_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetPhysicalDeviceQueueFamilyProperties *args)
7528 {
7529 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT});
7530
7531 /* skip args->physicalDevice */
7532 if (vn_encode_simple_pointer(enc, args->pQueueFamilyPropertyCount))
7533 vn_encode_uint32_t(enc, args->pQueueFamilyPropertyCount);
7534 if (args->pQueueFamilyProperties) {
7535 vn_encode_array_size(enc, (args->pQueueFamilyPropertyCount ? *args->pQueueFamilyPropertyCount : 0));
7536 for (uint32_t i = 0; i < (args->pQueueFamilyPropertyCount ? *args->pQueueFamilyPropertyCount : 0); i++)
7537 vn_encode_VkQueueFamilyProperties(enc, &args->pQueueFamilyProperties[i]);
7538 } else {
7539 vn_encode_array_size(enc, 0);
7540 }
7541 }
7542
vn_decode_vkGetPhysicalDeviceMemoryProperties_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetPhysicalDeviceMemoryProperties * args)7543 static inline void vn_decode_vkGetPhysicalDeviceMemoryProperties_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetPhysicalDeviceMemoryProperties *args)
7544 {
7545 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
7546 if (vn_decode_simple_pointer(dec)) {
7547 args->pMemoryProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pMemoryProperties));
7548 if (!args->pMemoryProperties) return;
7549 vn_decode_VkPhysicalDeviceMemoryProperties_partial_temp(dec, args->pMemoryProperties);
7550 } else {
7551 args->pMemoryProperties = NULL;
7552 vn_cs_decoder_set_fatal(dec);
7553 }
7554 }
7555
vn_replace_vkGetPhysicalDeviceMemoryProperties_args_handle(struct vn_command_vkGetPhysicalDeviceMemoryProperties * args)7556 static inline void vn_replace_vkGetPhysicalDeviceMemoryProperties_args_handle(struct vn_command_vkGetPhysicalDeviceMemoryProperties *args)
7557 {
7558 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
7559 /* skip args->pMemoryProperties */
7560 }
7561
vn_encode_vkGetPhysicalDeviceMemoryProperties_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetPhysicalDeviceMemoryProperties * args)7562 static inline void vn_encode_vkGetPhysicalDeviceMemoryProperties_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetPhysicalDeviceMemoryProperties *args)
7563 {
7564 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT});
7565
7566 /* skip args->physicalDevice */
7567 if (vn_encode_simple_pointer(enc, args->pMemoryProperties))
7568 vn_encode_VkPhysicalDeviceMemoryProperties(enc, args->pMemoryProperties);
7569 }
7570
vn_decode_vkGetPhysicalDeviceFeatures_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetPhysicalDeviceFeatures * args)7571 static inline void vn_decode_vkGetPhysicalDeviceFeatures_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetPhysicalDeviceFeatures *args)
7572 {
7573 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
7574 if (vn_decode_simple_pointer(dec)) {
7575 args->pFeatures = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pFeatures));
7576 if (!args->pFeatures) return;
7577 vn_decode_VkPhysicalDeviceFeatures_partial_temp(dec, args->pFeatures);
7578 } else {
7579 args->pFeatures = NULL;
7580 vn_cs_decoder_set_fatal(dec);
7581 }
7582 }
7583
vn_replace_vkGetPhysicalDeviceFeatures_args_handle(struct vn_command_vkGetPhysicalDeviceFeatures * args)7584 static inline void vn_replace_vkGetPhysicalDeviceFeatures_args_handle(struct vn_command_vkGetPhysicalDeviceFeatures *args)
7585 {
7586 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
7587 /* skip args->pFeatures */
7588 }
7589
vn_encode_vkGetPhysicalDeviceFeatures_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetPhysicalDeviceFeatures * args)7590 static inline void vn_encode_vkGetPhysicalDeviceFeatures_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetPhysicalDeviceFeatures *args)
7591 {
7592 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT});
7593
7594 /* skip args->physicalDevice */
7595 if (vn_encode_simple_pointer(enc, args->pFeatures))
7596 vn_encode_VkPhysicalDeviceFeatures(enc, args->pFeatures);
7597 }
7598
vn_decode_vkGetPhysicalDeviceFormatProperties_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetPhysicalDeviceFormatProperties * args)7599 static inline void vn_decode_vkGetPhysicalDeviceFormatProperties_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetPhysicalDeviceFormatProperties *args)
7600 {
7601 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
7602 vn_decode_VkFormat(dec, &args->format);
7603 if (vn_decode_simple_pointer(dec)) {
7604 args->pFormatProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pFormatProperties));
7605 if (!args->pFormatProperties) return;
7606 vn_decode_VkFormatProperties_partial_temp(dec, args->pFormatProperties);
7607 } else {
7608 args->pFormatProperties = NULL;
7609 vn_cs_decoder_set_fatal(dec);
7610 }
7611 }
7612
vn_replace_vkGetPhysicalDeviceFormatProperties_args_handle(struct vn_command_vkGetPhysicalDeviceFormatProperties * args)7613 static inline void vn_replace_vkGetPhysicalDeviceFormatProperties_args_handle(struct vn_command_vkGetPhysicalDeviceFormatProperties *args)
7614 {
7615 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
7616 /* skip args->format */
7617 /* skip args->pFormatProperties */
7618 }
7619
vn_encode_vkGetPhysicalDeviceFormatProperties_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetPhysicalDeviceFormatProperties * args)7620 static inline void vn_encode_vkGetPhysicalDeviceFormatProperties_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetPhysicalDeviceFormatProperties *args)
7621 {
7622 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT});
7623
7624 /* skip args->physicalDevice */
7625 /* skip args->format */
7626 if (vn_encode_simple_pointer(enc, args->pFormatProperties))
7627 vn_encode_VkFormatProperties(enc, args->pFormatProperties);
7628 }
7629
vn_decode_vkGetPhysicalDeviceImageFormatProperties_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetPhysicalDeviceImageFormatProperties * args)7630 static inline void vn_decode_vkGetPhysicalDeviceImageFormatProperties_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetPhysicalDeviceImageFormatProperties *args)
7631 {
7632 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
7633 vn_decode_VkFormat(dec, &args->format);
7634 vn_decode_VkImageType(dec, &args->type);
7635 vn_decode_VkImageTiling(dec, &args->tiling);
7636 vn_decode_VkFlags(dec, &args->usage);
7637 vn_decode_VkFlags(dec, &args->flags);
7638 if (vn_decode_simple_pointer(dec)) {
7639 args->pImageFormatProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pImageFormatProperties));
7640 if (!args->pImageFormatProperties) return;
7641 vn_decode_VkImageFormatProperties_partial_temp(dec, args->pImageFormatProperties);
7642 } else {
7643 args->pImageFormatProperties = NULL;
7644 vn_cs_decoder_set_fatal(dec);
7645 }
7646 }
7647
vn_replace_vkGetPhysicalDeviceImageFormatProperties_args_handle(struct vn_command_vkGetPhysicalDeviceImageFormatProperties * args)7648 static inline void vn_replace_vkGetPhysicalDeviceImageFormatProperties_args_handle(struct vn_command_vkGetPhysicalDeviceImageFormatProperties *args)
7649 {
7650 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
7651 /* skip args->format */
7652 /* skip args->type */
7653 /* skip args->tiling */
7654 /* skip args->usage */
7655 /* skip args->flags */
7656 /* skip args->pImageFormatProperties */
7657 }
7658
vn_encode_vkGetPhysicalDeviceImageFormatProperties_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetPhysicalDeviceImageFormatProperties * args)7659 static inline void vn_encode_vkGetPhysicalDeviceImageFormatProperties_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetPhysicalDeviceImageFormatProperties *args)
7660 {
7661 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT});
7662
7663 vn_encode_VkResult(enc, &args->ret);
7664 /* skip args->physicalDevice */
7665 /* skip args->format */
7666 /* skip args->type */
7667 /* skip args->tiling */
7668 /* skip args->usage */
7669 /* skip args->flags */
7670 if (vn_encode_simple_pointer(enc, args->pImageFormatProperties))
7671 vn_encode_VkImageFormatProperties(enc, args->pImageFormatProperties);
7672 }
7673
vn_decode_vkCreateDevice_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCreateDevice * args)7674 static inline void vn_decode_vkCreateDevice_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCreateDevice *args)
7675 {
7676 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
7677 if (vn_decode_simple_pointer(dec)) {
7678 args->pCreateInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCreateInfo));
7679 if (!args->pCreateInfo) return;
7680 vn_decode_VkDeviceCreateInfo_temp(dec, (VkDeviceCreateInfo *)args->pCreateInfo);
7681 } else {
7682 args->pCreateInfo = NULL;
7683 vn_cs_decoder_set_fatal(dec);
7684 }
7685 if (vn_decode_simple_pointer(dec)) {
7686 vn_cs_decoder_set_fatal(dec);
7687 } else {
7688 args->pAllocator = NULL;
7689 }
7690 if (vn_decode_simple_pointer(dec)) {
7691 args->pDevice = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pDevice));
7692 if (!args->pDevice) return;
7693 vn_decode_VkDevice_temp(dec, args->pDevice);
7694 } else {
7695 args->pDevice = NULL;
7696 vn_cs_decoder_set_fatal(dec);
7697 }
7698 }
7699
vn_replace_vkCreateDevice_args_handle(struct vn_command_vkCreateDevice * args)7700 static inline void vn_replace_vkCreateDevice_args_handle(struct vn_command_vkCreateDevice *args)
7701 {
7702 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
7703 if (args->pCreateInfo)
7704 vn_replace_VkDeviceCreateInfo_handle((VkDeviceCreateInfo *)args->pCreateInfo);
7705 /* skip args->pAllocator */
7706 /* skip args->pDevice */
7707 }
7708
vn_encode_vkCreateDevice_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCreateDevice * args)7709 static inline void vn_encode_vkCreateDevice_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCreateDevice *args)
7710 {
7711 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCreateDevice_EXT});
7712
7713 vn_encode_VkResult(enc, &args->ret);
7714 /* skip args->physicalDevice */
7715 /* skip args->pCreateInfo */
7716 /* skip args->pAllocator */
7717 if (vn_encode_simple_pointer(enc, args->pDevice))
7718 vn_encode_VkDevice(enc, args->pDevice);
7719 }
7720
vn_decode_vkDestroyDevice_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkDestroyDevice * args)7721 static inline void vn_decode_vkDestroyDevice_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkDestroyDevice *args)
7722 {
7723 vn_decode_VkDevice_lookup(dec, &args->device);
7724 if (vn_decode_simple_pointer(dec)) {
7725 vn_cs_decoder_set_fatal(dec);
7726 } else {
7727 args->pAllocator = NULL;
7728 }
7729 }
7730
vn_replace_vkDestroyDevice_args_handle(struct vn_command_vkDestroyDevice * args)7731 static inline void vn_replace_vkDestroyDevice_args_handle(struct vn_command_vkDestroyDevice *args)
7732 {
7733 vn_replace_VkDevice_handle(&args->device);
7734 /* skip args->pAllocator */
7735 }
7736
vn_encode_vkDestroyDevice_reply(struct vn_cs_encoder * enc,const struct vn_command_vkDestroyDevice * args)7737 static inline void vn_encode_vkDestroyDevice_reply(struct vn_cs_encoder *enc, const struct vn_command_vkDestroyDevice *args)
7738 {
7739 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkDestroyDevice_EXT});
7740
7741 /* skip args->device */
7742 /* skip args->pAllocator */
7743 }
7744
vn_decode_vkEnumerateDeviceLayerProperties_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkEnumerateDeviceLayerProperties * args)7745 static inline void vn_decode_vkEnumerateDeviceLayerProperties_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkEnumerateDeviceLayerProperties *args)
7746 {
7747 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
7748 if (vn_decode_simple_pointer(dec)) {
7749 args->pPropertyCount = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pPropertyCount));
7750 if (!args->pPropertyCount) return;
7751 vn_decode_uint32_t(dec, args->pPropertyCount);
7752 } else {
7753 args->pPropertyCount = NULL;
7754 vn_cs_decoder_set_fatal(dec);
7755 }
7756 if (vn_peek_array_size(dec)) {
7757 const uint32_t iter_count = vn_decode_array_size(dec, (args->pPropertyCount ? *args->pPropertyCount : 0));
7758 args->pProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pProperties) * iter_count);
7759 if (!args->pProperties) return;
7760 for (uint32_t i = 0; i < iter_count; i++)
7761 vn_decode_VkLayerProperties_partial_temp(dec, &args->pProperties[i]);
7762 } else {
7763 vn_decode_array_size_unchecked(dec);
7764 args->pProperties = NULL;
7765 }
7766 }
7767
vn_replace_vkEnumerateDeviceLayerProperties_args_handle(struct vn_command_vkEnumerateDeviceLayerProperties * args)7768 static inline void vn_replace_vkEnumerateDeviceLayerProperties_args_handle(struct vn_command_vkEnumerateDeviceLayerProperties *args)
7769 {
7770 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
7771 /* skip args->pPropertyCount */
7772 /* skip args->pProperties */
7773 }
7774
vn_encode_vkEnumerateDeviceLayerProperties_reply(struct vn_cs_encoder * enc,const struct vn_command_vkEnumerateDeviceLayerProperties * args)7775 static inline void vn_encode_vkEnumerateDeviceLayerProperties_reply(struct vn_cs_encoder *enc, const struct vn_command_vkEnumerateDeviceLayerProperties *args)
7776 {
7777 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT});
7778
7779 vn_encode_VkResult(enc, &args->ret);
7780 /* skip args->physicalDevice */
7781 if (vn_encode_simple_pointer(enc, args->pPropertyCount))
7782 vn_encode_uint32_t(enc, args->pPropertyCount);
7783 if (args->pProperties) {
7784 vn_encode_array_size(enc, (args->pPropertyCount ? *args->pPropertyCount : 0));
7785 for (uint32_t i = 0; i < (args->pPropertyCount ? *args->pPropertyCount : 0); i++)
7786 vn_encode_VkLayerProperties(enc, &args->pProperties[i]);
7787 } else {
7788 vn_encode_array_size(enc, 0);
7789 }
7790 }
7791
vn_decode_vkEnumerateDeviceExtensionProperties_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkEnumerateDeviceExtensionProperties * args)7792 static inline void vn_decode_vkEnumerateDeviceExtensionProperties_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkEnumerateDeviceExtensionProperties *args)
7793 {
7794 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
7795 if (vn_peek_array_size(dec)) {
7796 const size_t string_size = vn_decode_array_size_unchecked(dec);
7797 args->pLayerName = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pLayerName) * string_size);
7798 if (!args->pLayerName) return;
7799 vn_decode_char_array(dec, (char *)args->pLayerName, string_size);
7800 } else {
7801 vn_decode_array_size_unchecked(dec);
7802 args->pLayerName = NULL;
7803 }
7804 if (vn_decode_simple_pointer(dec)) {
7805 args->pPropertyCount = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pPropertyCount));
7806 if (!args->pPropertyCount) return;
7807 vn_decode_uint32_t(dec, args->pPropertyCount);
7808 } else {
7809 args->pPropertyCount = NULL;
7810 vn_cs_decoder_set_fatal(dec);
7811 }
7812 if (vn_peek_array_size(dec)) {
7813 const uint32_t iter_count = vn_decode_array_size(dec, (args->pPropertyCount ? *args->pPropertyCount : 0));
7814 args->pProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pProperties) * iter_count);
7815 if (!args->pProperties) return;
7816 for (uint32_t i = 0; i < iter_count; i++)
7817 vn_decode_VkExtensionProperties_partial_temp(dec, &args->pProperties[i]);
7818 } else {
7819 vn_decode_array_size_unchecked(dec);
7820 args->pProperties = NULL;
7821 }
7822 }
7823
vn_replace_vkEnumerateDeviceExtensionProperties_args_handle(struct vn_command_vkEnumerateDeviceExtensionProperties * args)7824 static inline void vn_replace_vkEnumerateDeviceExtensionProperties_args_handle(struct vn_command_vkEnumerateDeviceExtensionProperties *args)
7825 {
7826 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
7827 /* skip args->pLayerName */
7828 /* skip args->pPropertyCount */
7829 /* skip args->pProperties */
7830 }
7831
vn_encode_vkEnumerateDeviceExtensionProperties_reply(struct vn_cs_encoder * enc,const struct vn_command_vkEnumerateDeviceExtensionProperties * args)7832 static inline void vn_encode_vkEnumerateDeviceExtensionProperties_reply(struct vn_cs_encoder *enc, const struct vn_command_vkEnumerateDeviceExtensionProperties *args)
7833 {
7834 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT});
7835
7836 vn_encode_VkResult(enc, &args->ret);
7837 /* skip args->physicalDevice */
7838 /* skip args->pLayerName */
7839 if (vn_encode_simple_pointer(enc, args->pPropertyCount))
7840 vn_encode_uint32_t(enc, args->pPropertyCount);
7841 if (args->pProperties) {
7842 vn_encode_array_size(enc, (args->pPropertyCount ? *args->pPropertyCount : 0));
7843 for (uint32_t i = 0; i < (args->pPropertyCount ? *args->pPropertyCount : 0); i++)
7844 vn_encode_VkExtensionProperties(enc, &args->pProperties[i]);
7845 } else {
7846 vn_encode_array_size(enc, 0);
7847 }
7848 }
7849
vn_decode_vkGetDeviceQueue_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetDeviceQueue * args)7850 static inline void vn_decode_vkGetDeviceQueue_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetDeviceQueue *args)
7851 {
7852 vn_decode_VkDevice_lookup(dec, &args->device);
7853 vn_decode_uint32_t(dec, &args->queueFamilyIndex);
7854 vn_decode_uint32_t(dec, &args->queueIndex);
7855 if (vn_decode_simple_pointer(dec)) {
7856 args->pQueue = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pQueue));
7857 if (!args->pQueue) return;
7858 vn_decode_VkQueue_temp(dec, args->pQueue);
7859 } else {
7860 args->pQueue = NULL;
7861 vn_cs_decoder_set_fatal(dec);
7862 }
7863 }
7864
vn_replace_vkGetDeviceQueue_args_handle(struct vn_command_vkGetDeviceQueue * args)7865 static inline void vn_replace_vkGetDeviceQueue_args_handle(struct vn_command_vkGetDeviceQueue *args)
7866 {
7867 vn_replace_VkDevice_handle(&args->device);
7868 /* skip args->queueFamilyIndex */
7869 /* skip args->queueIndex */
7870 /* skip args->pQueue */
7871 }
7872
vn_encode_vkGetDeviceQueue_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetDeviceQueue * args)7873 static inline void vn_encode_vkGetDeviceQueue_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetDeviceQueue *args)
7874 {
7875 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetDeviceQueue_EXT});
7876
7877 /* skip args->device */
7878 /* skip args->queueFamilyIndex */
7879 /* skip args->queueIndex */
7880 if (vn_encode_simple_pointer(enc, args->pQueue))
7881 vn_encode_VkQueue(enc, args->pQueue);
7882 }
7883
vn_decode_vkDeviceWaitIdle_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkDeviceWaitIdle * args)7884 static inline void vn_decode_vkDeviceWaitIdle_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkDeviceWaitIdle *args)
7885 {
7886 vn_decode_VkDevice_lookup(dec, &args->device);
7887 }
7888
vn_replace_vkDeviceWaitIdle_args_handle(struct vn_command_vkDeviceWaitIdle * args)7889 static inline void vn_replace_vkDeviceWaitIdle_args_handle(struct vn_command_vkDeviceWaitIdle *args)
7890 {
7891 vn_replace_VkDevice_handle(&args->device);
7892 }
7893
vn_encode_vkDeviceWaitIdle_reply(struct vn_cs_encoder * enc,const struct vn_command_vkDeviceWaitIdle * args)7894 static inline void vn_encode_vkDeviceWaitIdle_reply(struct vn_cs_encoder *enc, const struct vn_command_vkDeviceWaitIdle *args)
7895 {
7896 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT});
7897
7898 vn_encode_VkResult(enc, &args->ret);
7899 /* skip args->device */
7900 }
7901
vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetPhysicalDeviceSparseImageFormatProperties * args)7902 static inline void vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetPhysicalDeviceSparseImageFormatProperties *args)
7903 {
7904 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
7905 vn_decode_VkFormat(dec, &args->format);
7906 vn_decode_VkImageType(dec, &args->type);
7907 vn_decode_VkSampleCountFlagBits(dec, &args->samples);
7908 vn_decode_VkFlags(dec, &args->usage);
7909 vn_decode_VkImageTiling(dec, &args->tiling);
7910 if (vn_decode_simple_pointer(dec)) {
7911 args->pPropertyCount = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pPropertyCount));
7912 if (!args->pPropertyCount) return;
7913 vn_decode_uint32_t(dec, args->pPropertyCount);
7914 } else {
7915 args->pPropertyCount = NULL;
7916 vn_cs_decoder_set_fatal(dec);
7917 }
7918 if (vn_peek_array_size(dec)) {
7919 const uint32_t iter_count = vn_decode_array_size(dec, (args->pPropertyCount ? *args->pPropertyCount : 0));
7920 args->pProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pProperties) * iter_count);
7921 if (!args->pProperties) return;
7922 for (uint32_t i = 0; i < iter_count; i++)
7923 vn_decode_VkSparseImageFormatProperties_partial_temp(dec, &args->pProperties[i]);
7924 } else {
7925 vn_decode_array_size_unchecked(dec);
7926 args->pProperties = NULL;
7927 }
7928 }
7929
vn_replace_vkGetPhysicalDeviceSparseImageFormatProperties_args_handle(struct vn_command_vkGetPhysicalDeviceSparseImageFormatProperties * args)7930 static inline void vn_replace_vkGetPhysicalDeviceSparseImageFormatProperties_args_handle(struct vn_command_vkGetPhysicalDeviceSparseImageFormatProperties *args)
7931 {
7932 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
7933 /* skip args->format */
7934 /* skip args->type */
7935 /* skip args->samples */
7936 /* skip args->usage */
7937 /* skip args->tiling */
7938 /* skip args->pPropertyCount */
7939 /* skip args->pProperties */
7940 }
7941
vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetPhysicalDeviceSparseImageFormatProperties * args)7942 static inline void vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetPhysicalDeviceSparseImageFormatProperties *args)
7943 {
7944 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT});
7945
7946 /* skip args->physicalDevice */
7947 /* skip args->format */
7948 /* skip args->type */
7949 /* skip args->samples */
7950 /* skip args->usage */
7951 /* skip args->tiling */
7952 if (vn_encode_simple_pointer(enc, args->pPropertyCount))
7953 vn_encode_uint32_t(enc, args->pPropertyCount);
7954 if (args->pProperties) {
7955 vn_encode_array_size(enc, (args->pPropertyCount ? *args->pPropertyCount : 0));
7956 for (uint32_t i = 0; i < (args->pPropertyCount ? *args->pPropertyCount : 0); i++)
7957 vn_encode_VkSparseImageFormatProperties(enc, &args->pProperties[i]);
7958 } else {
7959 vn_encode_array_size(enc, 0);
7960 }
7961 }
7962
vn_decode_vkGetPhysicalDeviceFeatures2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetPhysicalDeviceFeatures2 * args)7963 static inline void vn_decode_vkGetPhysicalDeviceFeatures2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetPhysicalDeviceFeatures2 *args)
7964 {
7965 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
7966 if (vn_decode_simple_pointer(dec)) {
7967 args->pFeatures = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pFeatures));
7968 if (!args->pFeatures) return;
7969 vn_decode_VkPhysicalDeviceFeatures2_partial_temp(dec, args->pFeatures);
7970 } else {
7971 args->pFeatures = NULL;
7972 vn_cs_decoder_set_fatal(dec);
7973 }
7974 }
7975
vn_replace_vkGetPhysicalDeviceFeatures2_args_handle(struct vn_command_vkGetPhysicalDeviceFeatures2 * args)7976 static inline void vn_replace_vkGetPhysicalDeviceFeatures2_args_handle(struct vn_command_vkGetPhysicalDeviceFeatures2 *args)
7977 {
7978 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
7979 /* skip args->pFeatures */
7980 }
7981
vn_encode_vkGetPhysicalDeviceFeatures2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetPhysicalDeviceFeatures2 * args)7982 static inline void vn_encode_vkGetPhysicalDeviceFeatures2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetPhysicalDeviceFeatures2 *args)
7983 {
7984 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT});
7985
7986 /* skip args->physicalDevice */
7987 if (vn_encode_simple_pointer(enc, args->pFeatures))
7988 vn_encode_VkPhysicalDeviceFeatures2(enc, args->pFeatures);
7989 }
7990
vn_decode_vkGetPhysicalDeviceProperties2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetPhysicalDeviceProperties2 * args)7991 static inline void vn_decode_vkGetPhysicalDeviceProperties2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetPhysicalDeviceProperties2 *args)
7992 {
7993 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
7994 if (vn_decode_simple_pointer(dec)) {
7995 args->pProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pProperties));
7996 if (!args->pProperties) return;
7997 vn_decode_VkPhysicalDeviceProperties2_partial_temp(dec, args->pProperties);
7998 } else {
7999 args->pProperties = NULL;
8000 vn_cs_decoder_set_fatal(dec);
8001 }
8002 }
8003
vn_replace_vkGetPhysicalDeviceProperties2_args_handle(struct vn_command_vkGetPhysicalDeviceProperties2 * args)8004 static inline void vn_replace_vkGetPhysicalDeviceProperties2_args_handle(struct vn_command_vkGetPhysicalDeviceProperties2 *args)
8005 {
8006 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
8007 /* skip args->pProperties */
8008 }
8009
vn_encode_vkGetPhysicalDeviceProperties2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetPhysicalDeviceProperties2 * args)8010 static inline void vn_encode_vkGetPhysicalDeviceProperties2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetPhysicalDeviceProperties2 *args)
8011 {
8012 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT});
8013
8014 /* skip args->physicalDevice */
8015 if (vn_encode_simple_pointer(enc, args->pProperties))
8016 vn_encode_VkPhysicalDeviceProperties2(enc, args->pProperties);
8017 }
8018
vn_decode_vkGetPhysicalDeviceFormatProperties2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetPhysicalDeviceFormatProperties2 * args)8019 static inline void vn_decode_vkGetPhysicalDeviceFormatProperties2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetPhysicalDeviceFormatProperties2 *args)
8020 {
8021 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
8022 vn_decode_VkFormat(dec, &args->format);
8023 if (vn_decode_simple_pointer(dec)) {
8024 args->pFormatProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pFormatProperties));
8025 if (!args->pFormatProperties) return;
8026 vn_decode_VkFormatProperties2_partial_temp(dec, args->pFormatProperties);
8027 } else {
8028 args->pFormatProperties = NULL;
8029 vn_cs_decoder_set_fatal(dec);
8030 }
8031 }
8032
vn_replace_vkGetPhysicalDeviceFormatProperties2_args_handle(struct vn_command_vkGetPhysicalDeviceFormatProperties2 * args)8033 static inline void vn_replace_vkGetPhysicalDeviceFormatProperties2_args_handle(struct vn_command_vkGetPhysicalDeviceFormatProperties2 *args)
8034 {
8035 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
8036 /* skip args->format */
8037 /* skip args->pFormatProperties */
8038 }
8039
vn_encode_vkGetPhysicalDeviceFormatProperties2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetPhysicalDeviceFormatProperties2 * args)8040 static inline void vn_encode_vkGetPhysicalDeviceFormatProperties2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetPhysicalDeviceFormatProperties2 *args)
8041 {
8042 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT});
8043
8044 /* skip args->physicalDevice */
8045 /* skip args->format */
8046 if (vn_encode_simple_pointer(enc, args->pFormatProperties))
8047 vn_encode_VkFormatProperties2(enc, args->pFormatProperties);
8048 }
8049
vn_decode_vkGetPhysicalDeviceImageFormatProperties2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetPhysicalDeviceImageFormatProperties2 * args)8050 static inline void vn_decode_vkGetPhysicalDeviceImageFormatProperties2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetPhysicalDeviceImageFormatProperties2 *args)
8051 {
8052 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
8053 if (vn_decode_simple_pointer(dec)) {
8054 args->pImageFormatInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pImageFormatInfo));
8055 if (!args->pImageFormatInfo) return;
8056 vn_decode_VkPhysicalDeviceImageFormatInfo2_temp(dec, (VkPhysicalDeviceImageFormatInfo2 *)args->pImageFormatInfo);
8057 } else {
8058 args->pImageFormatInfo = NULL;
8059 vn_cs_decoder_set_fatal(dec);
8060 }
8061 if (vn_decode_simple_pointer(dec)) {
8062 args->pImageFormatProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pImageFormatProperties));
8063 if (!args->pImageFormatProperties) return;
8064 vn_decode_VkImageFormatProperties2_partial_temp(dec, args->pImageFormatProperties);
8065 } else {
8066 args->pImageFormatProperties = NULL;
8067 vn_cs_decoder_set_fatal(dec);
8068 }
8069 }
8070
vn_replace_vkGetPhysicalDeviceImageFormatProperties2_args_handle(struct vn_command_vkGetPhysicalDeviceImageFormatProperties2 * args)8071 static inline void vn_replace_vkGetPhysicalDeviceImageFormatProperties2_args_handle(struct vn_command_vkGetPhysicalDeviceImageFormatProperties2 *args)
8072 {
8073 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
8074 if (args->pImageFormatInfo)
8075 vn_replace_VkPhysicalDeviceImageFormatInfo2_handle((VkPhysicalDeviceImageFormatInfo2 *)args->pImageFormatInfo);
8076 /* skip args->pImageFormatProperties */
8077 }
8078
vn_encode_vkGetPhysicalDeviceImageFormatProperties2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetPhysicalDeviceImageFormatProperties2 * args)8079 static inline void vn_encode_vkGetPhysicalDeviceImageFormatProperties2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetPhysicalDeviceImageFormatProperties2 *args)
8080 {
8081 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT});
8082
8083 vn_encode_VkResult(enc, &args->ret);
8084 /* skip args->physicalDevice */
8085 /* skip args->pImageFormatInfo */
8086 if (vn_encode_simple_pointer(enc, args->pImageFormatProperties))
8087 vn_encode_VkImageFormatProperties2(enc, args->pImageFormatProperties);
8088 }
8089
vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetPhysicalDeviceQueueFamilyProperties2 * args)8090 static inline void vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetPhysicalDeviceQueueFamilyProperties2 *args)
8091 {
8092 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
8093 if (vn_decode_simple_pointer(dec)) {
8094 args->pQueueFamilyPropertyCount = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pQueueFamilyPropertyCount));
8095 if (!args->pQueueFamilyPropertyCount) return;
8096 vn_decode_uint32_t(dec, args->pQueueFamilyPropertyCount);
8097 } else {
8098 args->pQueueFamilyPropertyCount = NULL;
8099 vn_cs_decoder_set_fatal(dec);
8100 }
8101 if (vn_peek_array_size(dec)) {
8102 const uint32_t iter_count = vn_decode_array_size(dec, (args->pQueueFamilyPropertyCount ? *args->pQueueFamilyPropertyCount : 0));
8103 args->pQueueFamilyProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pQueueFamilyProperties) * iter_count);
8104 if (!args->pQueueFamilyProperties) return;
8105 for (uint32_t i = 0; i < iter_count; i++)
8106 vn_decode_VkQueueFamilyProperties2_partial_temp(dec, &args->pQueueFamilyProperties[i]);
8107 } else {
8108 vn_decode_array_size_unchecked(dec);
8109 args->pQueueFamilyProperties = NULL;
8110 }
8111 }
8112
vn_replace_vkGetPhysicalDeviceQueueFamilyProperties2_args_handle(struct vn_command_vkGetPhysicalDeviceQueueFamilyProperties2 * args)8113 static inline void vn_replace_vkGetPhysicalDeviceQueueFamilyProperties2_args_handle(struct vn_command_vkGetPhysicalDeviceQueueFamilyProperties2 *args)
8114 {
8115 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
8116 /* skip args->pQueueFamilyPropertyCount */
8117 /* skip args->pQueueFamilyProperties */
8118 }
8119
vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetPhysicalDeviceQueueFamilyProperties2 * args)8120 static inline void vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetPhysicalDeviceQueueFamilyProperties2 *args)
8121 {
8122 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT});
8123
8124 /* skip args->physicalDevice */
8125 if (vn_encode_simple_pointer(enc, args->pQueueFamilyPropertyCount))
8126 vn_encode_uint32_t(enc, args->pQueueFamilyPropertyCount);
8127 if (args->pQueueFamilyProperties) {
8128 vn_encode_array_size(enc, (args->pQueueFamilyPropertyCount ? *args->pQueueFamilyPropertyCount : 0));
8129 for (uint32_t i = 0; i < (args->pQueueFamilyPropertyCount ? *args->pQueueFamilyPropertyCount : 0); i++)
8130 vn_encode_VkQueueFamilyProperties2(enc, &args->pQueueFamilyProperties[i]);
8131 } else {
8132 vn_encode_array_size(enc, 0);
8133 }
8134 }
8135
vn_decode_vkGetPhysicalDeviceMemoryProperties2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetPhysicalDeviceMemoryProperties2 * args)8136 static inline void vn_decode_vkGetPhysicalDeviceMemoryProperties2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetPhysicalDeviceMemoryProperties2 *args)
8137 {
8138 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
8139 if (vn_decode_simple_pointer(dec)) {
8140 args->pMemoryProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pMemoryProperties));
8141 if (!args->pMemoryProperties) return;
8142 vn_decode_VkPhysicalDeviceMemoryProperties2_partial_temp(dec, args->pMemoryProperties);
8143 } else {
8144 args->pMemoryProperties = NULL;
8145 vn_cs_decoder_set_fatal(dec);
8146 }
8147 }
8148
vn_replace_vkGetPhysicalDeviceMemoryProperties2_args_handle(struct vn_command_vkGetPhysicalDeviceMemoryProperties2 * args)8149 static inline void vn_replace_vkGetPhysicalDeviceMemoryProperties2_args_handle(struct vn_command_vkGetPhysicalDeviceMemoryProperties2 *args)
8150 {
8151 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
8152 /* skip args->pMemoryProperties */
8153 }
8154
vn_encode_vkGetPhysicalDeviceMemoryProperties2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetPhysicalDeviceMemoryProperties2 * args)8155 static inline void vn_encode_vkGetPhysicalDeviceMemoryProperties2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetPhysicalDeviceMemoryProperties2 *args)
8156 {
8157 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT});
8158
8159 /* skip args->physicalDevice */
8160 if (vn_encode_simple_pointer(enc, args->pMemoryProperties))
8161 vn_encode_VkPhysicalDeviceMemoryProperties2(enc, args->pMemoryProperties);
8162 }
8163
vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetPhysicalDeviceSparseImageFormatProperties2 * args)8164 static inline void vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetPhysicalDeviceSparseImageFormatProperties2 *args)
8165 {
8166 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
8167 if (vn_decode_simple_pointer(dec)) {
8168 args->pFormatInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pFormatInfo));
8169 if (!args->pFormatInfo) return;
8170 vn_decode_VkPhysicalDeviceSparseImageFormatInfo2_temp(dec, (VkPhysicalDeviceSparseImageFormatInfo2 *)args->pFormatInfo);
8171 } else {
8172 args->pFormatInfo = NULL;
8173 vn_cs_decoder_set_fatal(dec);
8174 }
8175 if (vn_decode_simple_pointer(dec)) {
8176 args->pPropertyCount = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pPropertyCount));
8177 if (!args->pPropertyCount) return;
8178 vn_decode_uint32_t(dec, args->pPropertyCount);
8179 } else {
8180 args->pPropertyCount = NULL;
8181 vn_cs_decoder_set_fatal(dec);
8182 }
8183 if (vn_peek_array_size(dec)) {
8184 const uint32_t iter_count = vn_decode_array_size(dec, (args->pPropertyCount ? *args->pPropertyCount : 0));
8185 args->pProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pProperties) * iter_count);
8186 if (!args->pProperties) return;
8187 for (uint32_t i = 0; i < iter_count; i++)
8188 vn_decode_VkSparseImageFormatProperties2_partial_temp(dec, &args->pProperties[i]);
8189 } else {
8190 vn_decode_array_size_unchecked(dec);
8191 args->pProperties = NULL;
8192 }
8193 }
8194
vn_replace_vkGetPhysicalDeviceSparseImageFormatProperties2_args_handle(struct vn_command_vkGetPhysicalDeviceSparseImageFormatProperties2 * args)8195 static inline void vn_replace_vkGetPhysicalDeviceSparseImageFormatProperties2_args_handle(struct vn_command_vkGetPhysicalDeviceSparseImageFormatProperties2 *args)
8196 {
8197 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
8198 if (args->pFormatInfo)
8199 vn_replace_VkPhysicalDeviceSparseImageFormatInfo2_handle((VkPhysicalDeviceSparseImageFormatInfo2 *)args->pFormatInfo);
8200 /* skip args->pPropertyCount */
8201 /* skip args->pProperties */
8202 }
8203
vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetPhysicalDeviceSparseImageFormatProperties2 * args)8204 static inline void vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetPhysicalDeviceSparseImageFormatProperties2 *args)
8205 {
8206 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT});
8207
8208 /* skip args->physicalDevice */
8209 /* skip args->pFormatInfo */
8210 if (vn_encode_simple_pointer(enc, args->pPropertyCount))
8211 vn_encode_uint32_t(enc, args->pPropertyCount);
8212 if (args->pProperties) {
8213 vn_encode_array_size(enc, (args->pPropertyCount ? *args->pPropertyCount : 0));
8214 for (uint32_t i = 0; i < (args->pPropertyCount ? *args->pPropertyCount : 0); i++)
8215 vn_encode_VkSparseImageFormatProperties2(enc, &args->pProperties[i]);
8216 } else {
8217 vn_encode_array_size(enc, 0);
8218 }
8219 }
8220
vn_decode_vkGetPhysicalDeviceExternalBufferProperties_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetPhysicalDeviceExternalBufferProperties * args)8221 static inline void vn_decode_vkGetPhysicalDeviceExternalBufferProperties_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetPhysicalDeviceExternalBufferProperties *args)
8222 {
8223 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
8224 if (vn_decode_simple_pointer(dec)) {
8225 args->pExternalBufferInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pExternalBufferInfo));
8226 if (!args->pExternalBufferInfo) return;
8227 vn_decode_VkPhysicalDeviceExternalBufferInfo_temp(dec, (VkPhysicalDeviceExternalBufferInfo *)args->pExternalBufferInfo);
8228 } else {
8229 args->pExternalBufferInfo = NULL;
8230 vn_cs_decoder_set_fatal(dec);
8231 }
8232 if (vn_decode_simple_pointer(dec)) {
8233 args->pExternalBufferProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pExternalBufferProperties));
8234 if (!args->pExternalBufferProperties) return;
8235 vn_decode_VkExternalBufferProperties_partial_temp(dec, args->pExternalBufferProperties);
8236 } else {
8237 args->pExternalBufferProperties = NULL;
8238 vn_cs_decoder_set_fatal(dec);
8239 }
8240 }
8241
vn_replace_vkGetPhysicalDeviceExternalBufferProperties_args_handle(struct vn_command_vkGetPhysicalDeviceExternalBufferProperties * args)8242 static inline void vn_replace_vkGetPhysicalDeviceExternalBufferProperties_args_handle(struct vn_command_vkGetPhysicalDeviceExternalBufferProperties *args)
8243 {
8244 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
8245 if (args->pExternalBufferInfo)
8246 vn_replace_VkPhysicalDeviceExternalBufferInfo_handle((VkPhysicalDeviceExternalBufferInfo *)args->pExternalBufferInfo);
8247 /* skip args->pExternalBufferProperties */
8248 }
8249
vn_encode_vkGetPhysicalDeviceExternalBufferProperties_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetPhysicalDeviceExternalBufferProperties * args)8250 static inline void vn_encode_vkGetPhysicalDeviceExternalBufferProperties_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetPhysicalDeviceExternalBufferProperties *args)
8251 {
8252 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT});
8253
8254 /* skip args->physicalDevice */
8255 /* skip args->pExternalBufferInfo */
8256 if (vn_encode_simple_pointer(enc, args->pExternalBufferProperties))
8257 vn_encode_VkExternalBufferProperties(enc, args->pExternalBufferProperties);
8258 }
8259
vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetPhysicalDeviceExternalSemaphoreProperties * args)8260 static inline void vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetPhysicalDeviceExternalSemaphoreProperties *args)
8261 {
8262 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
8263 if (vn_decode_simple_pointer(dec)) {
8264 args->pExternalSemaphoreInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pExternalSemaphoreInfo));
8265 if (!args->pExternalSemaphoreInfo) return;
8266 vn_decode_VkPhysicalDeviceExternalSemaphoreInfo_temp(dec, (VkPhysicalDeviceExternalSemaphoreInfo *)args->pExternalSemaphoreInfo);
8267 } else {
8268 args->pExternalSemaphoreInfo = NULL;
8269 vn_cs_decoder_set_fatal(dec);
8270 }
8271 if (vn_decode_simple_pointer(dec)) {
8272 args->pExternalSemaphoreProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pExternalSemaphoreProperties));
8273 if (!args->pExternalSemaphoreProperties) return;
8274 vn_decode_VkExternalSemaphoreProperties_partial_temp(dec, args->pExternalSemaphoreProperties);
8275 } else {
8276 args->pExternalSemaphoreProperties = NULL;
8277 vn_cs_decoder_set_fatal(dec);
8278 }
8279 }
8280
vn_replace_vkGetPhysicalDeviceExternalSemaphoreProperties_args_handle(struct vn_command_vkGetPhysicalDeviceExternalSemaphoreProperties * args)8281 static inline void vn_replace_vkGetPhysicalDeviceExternalSemaphoreProperties_args_handle(struct vn_command_vkGetPhysicalDeviceExternalSemaphoreProperties *args)
8282 {
8283 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
8284 if (args->pExternalSemaphoreInfo)
8285 vn_replace_VkPhysicalDeviceExternalSemaphoreInfo_handle((VkPhysicalDeviceExternalSemaphoreInfo *)args->pExternalSemaphoreInfo);
8286 /* skip args->pExternalSemaphoreProperties */
8287 }
8288
vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetPhysicalDeviceExternalSemaphoreProperties * args)8289 static inline void vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetPhysicalDeviceExternalSemaphoreProperties *args)
8290 {
8291 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT});
8292
8293 /* skip args->physicalDevice */
8294 /* skip args->pExternalSemaphoreInfo */
8295 if (vn_encode_simple_pointer(enc, args->pExternalSemaphoreProperties))
8296 vn_encode_VkExternalSemaphoreProperties(enc, args->pExternalSemaphoreProperties);
8297 }
8298
vn_decode_vkGetPhysicalDeviceExternalFenceProperties_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetPhysicalDeviceExternalFenceProperties * args)8299 static inline void vn_decode_vkGetPhysicalDeviceExternalFenceProperties_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetPhysicalDeviceExternalFenceProperties *args)
8300 {
8301 vn_decode_VkPhysicalDevice_lookup(dec, &args->physicalDevice);
8302 if (vn_decode_simple_pointer(dec)) {
8303 args->pExternalFenceInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pExternalFenceInfo));
8304 if (!args->pExternalFenceInfo) return;
8305 vn_decode_VkPhysicalDeviceExternalFenceInfo_temp(dec, (VkPhysicalDeviceExternalFenceInfo *)args->pExternalFenceInfo);
8306 } else {
8307 args->pExternalFenceInfo = NULL;
8308 vn_cs_decoder_set_fatal(dec);
8309 }
8310 if (vn_decode_simple_pointer(dec)) {
8311 args->pExternalFenceProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pExternalFenceProperties));
8312 if (!args->pExternalFenceProperties) return;
8313 vn_decode_VkExternalFenceProperties_partial_temp(dec, args->pExternalFenceProperties);
8314 } else {
8315 args->pExternalFenceProperties = NULL;
8316 vn_cs_decoder_set_fatal(dec);
8317 }
8318 }
8319
vn_replace_vkGetPhysicalDeviceExternalFenceProperties_args_handle(struct vn_command_vkGetPhysicalDeviceExternalFenceProperties * args)8320 static inline void vn_replace_vkGetPhysicalDeviceExternalFenceProperties_args_handle(struct vn_command_vkGetPhysicalDeviceExternalFenceProperties *args)
8321 {
8322 vn_replace_VkPhysicalDevice_handle(&args->physicalDevice);
8323 if (args->pExternalFenceInfo)
8324 vn_replace_VkPhysicalDeviceExternalFenceInfo_handle((VkPhysicalDeviceExternalFenceInfo *)args->pExternalFenceInfo);
8325 /* skip args->pExternalFenceProperties */
8326 }
8327
vn_encode_vkGetPhysicalDeviceExternalFenceProperties_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetPhysicalDeviceExternalFenceProperties * args)8328 static inline void vn_encode_vkGetPhysicalDeviceExternalFenceProperties_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetPhysicalDeviceExternalFenceProperties *args)
8329 {
8330 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT});
8331
8332 /* skip args->physicalDevice */
8333 /* skip args->pExternalFenceInfo */
8334 if (vn_encode_simple_pointer(enc, args->pExternalFenceProperties))
8335 vn_encode_VkExternalFenceProperties(enc, args->pExternalFenceProperties);
8336 }
8337
vn_decode_vkEnumeratePhysicalDeviceGroups_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkEnumeratePhysicalDeviceGroups * args)8338 static inline void vn_decode_vkEnumeratePhysicalDeviceGroups_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkEnumeratePhysicalDeviceGroups *args)
8339 {
8340 vn_decode_VkInstance_lookup(dec, &args->instance);
8341 if (vn_decode_simple_pointer(dec)) {
8342 args->pPhysicalDeviceGroupCount = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pPhysicalDeviceGroupCount));
8343 if (!args->pPhysicalDeviceGroupCount) return;
8344 vn_decode_uint32_t(dec, args->pPhysicalDeviceGroupCount);
8345 } else {
8346 args->pPhysicalDeviceGroupCount = NULL;
8347 vn_cs_decoder_set_fatal(dec);
8348 }
8349 if (vn_peek_array_size(dec)) {
8350 const uint32_t iter_count = vn_decode_array_size(dec, (args->pPhysicalDeviceGroupCount ? *args->pPhysicalDeviceGroupCount : 0));
8351 args->pPhysicalDeviceGroupProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pPhysicalDeviceGroupProperties) * iter_count);
8352 if (!args->pPhysicalDeviceGroupProperties) return;
8353 for (uint32_t i = 0; i < iter_count; i++)
8354 vn_decode_VkPhysicalDeviceGroupProperties_partial_temp(dec, &args->pPhysicalDeviceGroupProperties[i]);
8355 } else {
8356 vn_decode_array_size_unchecked(dec);
8357 args->pPhysicalDeviceGroupProperties = NULL;
8358 }
8359 }
8360
vn_replace_vkEnumeratePhysicalDeviceGroups_args_handle(struct vn_command_vkEnumeratePhysicalDeviceGroups * args)8361 static inline void vn_replace_vkEnumeratePhysicalDeviceGroups_args_handle(struct vn_command_vkEnumeratePhysicalDeviceGroups *args)
8362 {
8363 vn_replace_VkInstance_handle(&args->instance);
8364 /* skip args->pPhysicalDeviceGroupCount */
8365 /* skip args->pPhysicalDeviceGroupProperties */
8366 }
8367
vn_encode_vkEnumeratePhysicalDeviceGroups_reply(struct vn_cs_encoder * enc,const struct vn_command_vkEnumeratePhysicalDeviceGroups * args)8368 static inline void vn_encode_vkEnumeratePhysicalDeviceGroups_reply(struct vn_cs_encoder *enc, const struct vn_command_vkEnumeratePhysicalDeviceGroups *args)
8369 {
8370 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT});
8371
8372 vn_encode_VkResult(enc, &args->ret);
8373 /* skip args->instance */
8374 if (vn_encode_simple_pointer(enc, args->pPhysicalDeviceGroupCount))
8375 vn_encode_uint32_t(enc, args->pPhysicalDeviceGroupCount);
8376 if (args->pPhysicalDeviceGroupProperties) {
8377 vn_encode_array_size(enc, (args->pPhysicalDeviceGroupCount ? *args->pPhysicalDeviceGroupCount : 0));
8378 for (uint32_t i = 0; i < (args->pPhysicalDeviceGroupCount ? *args->pPhysicalDeviceGroupCount : 0); i++)
8379 vn_encode_VkPhysicalDeviceGroupProperties(enc, &args->pPhysicalDeviceGroupProperties[i]);
8380 } else {
8381 vn_encode_array_size(enc, 0);
8382 }
8383 }
8384
vn_decode_vkGetDeviceGroupPeerMemoryFeatures_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetDeviceGroupPeerMemoryFeatures * args)8385 static inline void vn_decode_vkGetDeviceGroupPeerMemoryFeatures_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetDeviceGroupPeerMemoryFeatures *args)
8386 {
8387 vn_decode_VkDevice_lookup(dec, &args->device);
8388 vn_decode_uint32_t(dec, &args->heapIndex);
8389 vn_decode_uint32_t(dec, &args->localDeviceIndex);
8390 vn_decode_uint32_t(dec, &args->remoteDeviceIndex);
8391 if (vn_decode_simple_pointer(dec)) {
8392 args->pPeerMemoryFeatures = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pPeerMemoryFeatures));
8393 if (!args->pPeerMemoryFeatures) return;
8394 } else {
8395 args->pPeerMemoryFeatures = NULL;
8396 vn_cs_decoder_set_fatal(dec);
8397 }
8398 }
8399
vn_replace_vkGetDeviceGroupPeerMemoryFeatures_args_handle(struct vn_command_vkGetDeviceGroupPeerMemoryFeatures * args)8400 static inline void vn_replace_vkGetDeviceGroupPeerMemoryFeatures_args_handle(struct vn_command_vkGetDeviceGroupPeerMemoryFeatures *args)
8401 {
8402 vn_replace_VkDevice_handle(&args->device);
8403 /* skip args->heapIndex */
8404 /* skip args->localDeviceIndex */
8405 /* skip args->remoteDeviceIndex */
8406 /* skip args->pPeerMemoryFeatures */
8407 }
8408
vn_encode_vkGetDeviceGroupPeerMemoryFeatures_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetDeviceGroupPeerMemoryFeatures * args)8409 static inline void vn_encode_vkGetDeviceGroupPeerMemoryFeatures_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetDeviceGroupPeerMemoryFeatures *args)
8410 {
8411 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT});
8412
8413 /* skip args->device */
8414 /* skip args->heapIndex */
8415 /* skip args->localDeviceIndex */
8416 /* skip args->remoteDeviceIndex */
8417 if (vn_encode_simple_pointer(enc, args->pPeerMemoryFeatures))
8418 vn_encode_VkFlags(enc, args->pPeerMemoryFeatures);
8419 }
8420
vn_decode_vkGetDeviceQueue2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetDeviceQueue2 * args)8421 static inline void vn_decode_vkGetDeviceQueue2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetDeviceQueue2 *args)
8422 {
8423 vn_decode_VkDevice_lookup(dec, &args->device);
8424 if (vn_decode_simple_pointer(dec)) {
8425 args->pQueueInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pQueueInfo));
8426 if (!args->pQueueInfo) return;
8427 vn_decode_VkDeviceQueueInfo2_temp(dec, (VkDeviceQueueInfo2 *)args->pQueueInfo);
8428 } else {
8429 args->pQueueInfo = NULL;
8430 vn_cs_decoder_set_fatal(dec);
8431 }
8432 if (vn_decode_simple_pointer(dec)) {
8433 args->pQueue = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pQueue));
8434 if (!args->pQueue) return;
8435 vn_decode_VkQueue_temp(dec, args->pQueue);
8436 } else {
8437 args->pQueue = NULL;
8438 vn_cs_decoder_set_fatal(dec);
8439 }
8440 }
8441
vn_replace_vkGetDeviceQueue2_args_handle(struct vn_command_vkGetDeviceQueue2 * args)8442 static inline void vn_replace_vkGetDeviceQueue2_args_handle(struct vn_command_vkGetDeviceQueue2 *args)
8443 {
8444 vn_replace_VkDevice_handle(&args->device);
8445 if (args->pQueueInfo)
8446 vn_replace_VkDeviceQueueInfo2_handle((VkDeviceQueueInfo2 *)args->pQueueInfo);
8447 /* skip args->pQueue */
8448 }
8449
vn_encode_vkGetDeviceQueue2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetDeviceQueue2 * args)8450 static inline void vn_encode_vkGetDeviceQueue2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetDeviceQueue2 *args)
8451 {
8452 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT});
8453
8454 /* skip args->device */
8455 /* skip args->pQueueInfo */
8456 if (vn_encode_simple_pointer(enc, args->pQueue))
8457 vn_encode_VkQueue(enc, args->pQueue);
8458 }
8459
vn_dispatch_vkEnumeratePhysicalDevices(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8460 static inline void vn_dispatch_vkEnumeratePhysicalDevices(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8461 {
8462 struct vn_command_vkEnumeratePhysicalDevices args;
8463
8464 if (!ctx->dispatch_vkEnumeratePhysicalDevices) {
8465 vn_cs_decoder_set_fatal(ctx->decoder);
8466 return;
8467 }
8468
8469 vn_decode_vkEnumeratePhysicalDevices_args_temp(ctx->decoder, &args);
8470 if (!args.instance) {
8471 vn_cs_decoder_set_fatal(ctx->decoder);
8472 return;
8473 }
8474
8475 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8476 ctx->dispatch_vkEnumeratePhysicalDevices(ctx, &args);
8477
8478 #ifdef DEBUG
8479 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
8480 vn_dispatch_debug_log(ctx, "vkEnumeratePhysicalDevices returned %d", args.ret);
8481 #endif
8482
8483 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8484 vn_encode_vkEnumeratePhysicalDevices_reply(ctx->encoder, &args);
8485
8486 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8487 }
8488
vn_dispatch_vkGetPhysicalDeviceProperties(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8489 static inline void vn_dispatch_vkGetPhysicalDeviceProperties(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8490 {
8491 struct vn_command_vkGetPhysicalDeviceProperties args;
8492
8493 if (!ctx->dispatch_vkGetPhysicalDeviceProperties) {
8494 vn_cs_decoder_set_fatal(ctx->decoder);
8495 return;
8496 }
8497
8498 vn_decode_vkGetPhysicalDeviceProperties_args_temp(ctx->decoder, &args);
8499 if (!args.physicalDevice) {
8500 vn_cs_decoder_set_fatal(ctx->decoder);
8501 return;
8502 }
8503
8504 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8505 ctx->dispatch_vkGetPhysicalDeviceProperties(ctx, &args);
8506
8507
8508 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8509 vn_encode_vkGetPhysicalDeviceProperties_reply(ctx->encoder, &args);
8510
8511 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8512 }
8513
vn_dispatch_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8514 static inline void vn_dispatch_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8515 {
8516 struct vn_command_vkGetPhysicalDeviceQueueFamilyProperties args;
8517
8518 if (!ctx->dispatch_vkGetPhysicalDeviceQueueFamilyProperties) {
8519 vn_cs_decoder_set_fatal(ctx->decoder);
8520 return;
8521 }
8522
8523 vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_args_temp(ctx->decoder, &args);
8524 if (!args.physicalDevice) {
8525 vn_cs_decoder_set_fatal(ctx->decoder);
8526 return;
8527 }
8528
8529 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8530 ctx->dispatch_vkGetPhysicalDeviceQueueFamilyProperties(ctx, &args);
8531
8532
8533 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8534 vn_encode_vkGetPhysicalDeviceQueueFamilyProperties_reply(ctx->encoder, &args);
8535
8536 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8537 }
8538
vn_dispatch_vkGetPhysicalDeviceMemoryProperties(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8539 static inline void vn_dispatch_vkGetPhysicalDeviceMemoryProperties(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8540 {
8541 struct vn_command_vkGetPhysicalDeviceMemoryProperties args;
8542
8543 if (!ctx->dispatch_vkGetPhysicalDeviceMemoryProperties) {
8544 vn_cs_decoder_set_fatal(ctx->decoder);
8545 return;
8546 }
8547
8548 vn_decode_vkGetPhysicalDeviceMemoryProperties_args_temp(ctx->decoder, &args);
8549 if (!args.physicalDevice) {
8550 vn_cs_decoder_set_fatal(ctx->decoder);
8551 return;
8552 }
8553
8554 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8555 ctx->dispatch_vkGetPhysicalDeviceMemoryProperties(ctx, &args);
8556
8557
8558 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8559 vn_encode_vkGetPhysicalDeviceMemoryProperties_reply(ctx->encoder, &args);
8560
8561 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8562 }
8563
vn_dispatch_vkGetPhysicalDeviceFeatures(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8564 static inline void vn_dispatch_vkGetPhysicalDeviceFeatures(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8565 {
8566 struct vn_command_vkGetPhysicalDeviceFeatures args;
8567
8568 if (!ctx->dispatch_vkGetPhysicalDeviceFeatures) {
8569 vn_cs_decoder_set_fatal(ctx->decoder);
8570 return;
8571 }
8572
8573 vn_decode_vkGetPhysicalDeviceFeatures_args_temp(ctx->decoder, &args);
8574 if (!args.physicalDevice) {
8575 vn_cs_decoder_set_fatal(ctx->decoder);
8576 return;
8577 }
8578
8579 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8580 ctx->dispatch_vkGetPhysicalDeviceFeatures(ctx, &args);
8581
8582
8583 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8584 vn_encode_vkGetPhysicalDeviceFeatures_reply(ctx->encoder, &args);
8585
8586 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8587 }
8588
vn_dispatch_vkGetPhysicalDeviceFormatProperties(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8589 static inline void vn_dispatch_vkGetPhysicalDeviceFormatProperties(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8590 {
8591 struct vn_command_vkGetPhysicalDeviceFormatProperties args;
8592
8593 if (!ctx->dispatch_vkGetPhysicalDeviceFormatProperties) {
8594 vn_cs_decoder_set_fatal(ctx->decoder);
8595 return;
8596 }
8597
8598 vn_decode_vkGetPhysicalDeviceFormatProperties_args_temp(ctx->decoder, &args);
8599 if (!args.physicalDevice) {
8600 vn_cs_decoder_set_fatal(ctx->decoder);
8601 return;
8602 }
8603
8604 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8605 ctx->dispatch_vkGetPhysicalDeviceFormatProperties(ctx, &args);
8606
8607
8608 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8609 vn_encode_vkGetPhysicalDeviceFormatProperties_reply(ctx->encoder, &args);
8610
8611 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8612 }
8613
vn_dispatch_vkGetPhysicalDeviceImageFormatProperties(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8614 static inline void vn_dispatch_vkGetPhysicalDeviceImageFormatProperties(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8615 {
8616 struct vn_command_vkGetPhysicalDeviceImageFormatProperties args;
8617
8618 if (!ctx->dispatch_vkGetPhysicalDeviceImageFormatProperties) {
8619 vn_cs_decoder_set_fatal(ctx->decoder);
8620 return;
8621 }
8622
8623 vn_decode_vkGetPhysicalDeviceImageFormatProperties_args_temp(ctx->decoder, &args);
8624 if (!args.physicalDevice) {
8625 vn_cs_decoder_set_fatal(ctx->decoder);
8626 return;
8627 }
8628
8629 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8630 ctx->dispatch_vkGetPhysicalDeviceImageFormatProperties(ctx, &args);
8631
8632 #ifdef DEBUG
8633 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
8634 vn_dispatch_debug_log(ctx, "vkGetPhysicalDeviceImageFormatProperties returned %d", args.ret);
8635 #endif
8636
8637 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8638 vn_encode_vkGetPhysicalDeviceImageFormatProperties_reply(ctx->encoder, &args);
8639
8640 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8641 }
8642
vn_dispatch_vkCreateDevice(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8643 static inline void vn_dispatch_vkCreateDevice(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8644 {
8645 struct vn_command_vkCreateDevice args;
8646
8647 if (!ctx->dispatch_vkCreateDevice) {
8648 vn_cs_decoder_set_fatal(ctx->decoder);
8649 return;
8650 }
8651
8652 vn_decode_vkCreateDevice_args_temp(ctx->decoder, &args);
8653 if (!args.physicalDevice) {
8654 vn_cs_decoder_set_fatal(ctx->decoder);
8655 return;
8656 }
8657
8658 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8659 ctx->dispatch_vkCreateDevice(ctx, &args);
8660
8661 #ifdef DEBUG
8662 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
8663 vn_dispatch_debug_log(ctx, "vkCreateDevice returned %d", args.ret);
8664 #endif
8665
8666 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8667 vn_encode_vkCreateDevice_reply(ctx->encoder, &args);
8668
8669 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8670 }
8671
vn_dispatch_vkDestroyDevice(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8672 static inline void vn_dispatch_vkDestroyDevice(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8673 {
8674 struct vn_command_vkDestroyDevice args;
8675
8676 if (!ctx->dispatch_vkDestroyDevice) {
8677 vn_cs_decoder_set_fatal(ctx->decoder);
8678 return;
8679 }
8680
8681 vn_decode_vkDestroyDevice_args_temp(ctx->decoder, &args);
8682 if (!args.device) {
8683 vn_cs_decoder_set_fatal(ctx->decoder);
8684 return;
8685 }
8686
8687 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8688 ctx->dispatch_vkDestroyDevice(ctx, &args);
8689
8690
8691 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8692 vn_encode_vkDestroyDevice_reply(ctx->encoder, &args);
8693
8694 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8695 }
8696
vn_dispatch_vkEnumerateDeviceLayerProperties(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8697 static inline void vn_dispatch_vkEnumerateDeviceLayerProperties(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8698 {
8699 struct vn_command_vkEnumerateDeviceLayerProperties args;
8700
8701 if (!ctx->dispatch_vkEnumerateDeviceLayerProperties) {
8702 vn_cs_decoder_set_fatal(ctx->decoder);
8703 return;
8704 }
8705
8706 vn_decode_vkEnumerateDeviceLayerProperties_args_temp(ctx->decoder, &args);
8707 if (!args.physicalDevice) {
8708 vn_cs_decoder_set_fatal(ctx->decoder);
8709 return;
8710 }
8711
8712 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8713 ctx->dispatch_vkEnumerateDeviceLayerProperties(ctx, &args);
8714
8715 #ifdef DEBUG
8716 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
8717 vn_dispatch_debug_log(ctx, "vkEnumerateDeviceLayerProperties returned %d", args.ret);
8718 #endif
8719
8720 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8721 vn_encode_vkEnumerateDeviceLayerProperties_reply(ctx->encoder, &args);
8722
8723 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8724 }
8725
vn_dispatch_vkEnumerateDeviceExtensionProperties(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8726 static inline void vn_dispatch_vkEnumerateDeviceExtensionProperties(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8727 {
8728 struct vn_command_vkEnumerateDeviceExtensionProperties args;
8729
8730 if (!ctx->dispatch_vkEnumerateDeviceExtensionProperties) {
8731 vn_cs_decoder_set_fatal(ctx->decoder);
8732 return;
8733 }
8734
8735 vn_decode_vkEnumerateDeviceExtensionProperties_args_temp(ctx->decoder, &args);
8736 if (!args.physicalDevice) {
8737 vn_cs_decoder_set_fatal(ctx->decoder);
8738 return;
8739 }
8740
8741 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8742 ctx->dispatch_vkEnumerateDeviceExtensionProperties(ctx, &args);
8743
8744 #ifdef DEBUG
8745 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
8746 vn_dispatch_debug_log(ctx, "vkEnumerateDeviceExtensionProperties returned %d", args.ret);
8747 #endif
8748
8749 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8750 vn_encode_vkEnumerateDeviceExtensionProperties_reply(ctx->encoder, &args);
8751
8752 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8753 }
8754
vn_dispatch_vkGetDeviceQueue(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8755 static inline void vn_dispatch_vkGetDeviceQueue(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8756 {
8757 struct vn_command_vkGetDeviceQueue args;
8758
8759 if (!ctx->dispatch_vkGetDeviceQueue) {
8760 vn_cs_decoder_set_fatal(ctx->decoder);
8761 return;
8762 }
8763
8764 vn_decode_vkGetDeviceQueue_args_temp(ctx->decoder, &args);
8765 if (!args.device) {
8766 vn_cs_decoder_set_fatal(ctx->decoder);
8767 return;
8768 }
8769
8770 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8771 ctx->dispatch_vkGetDeviceQueue(ctx, &args);
8772
8773
8774 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8775 vn_encode_vkGetDeviceQueue_reply(ctx->encoder, &args);
8776
8777 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8778 }
8779
vn_dispatch_vkDeviceWaitIdle(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8780 static inline void vn_dispatch_vkDeviceWaitIdle(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8781 {
8782 struct vn_command_vkDeviceWaitIdle args;
8783
8784 if (!ctx->dispatch_vkDeviceWaitIdle) {
8785 vn_cs_decoder_set_fatal(ctx->decoder);
8786 return;
8787 }
8788
8789 vn_decode_vkDeviceWaitIdle_args_temp(ctx->decoder, &args);
8790 if (!args.device) {
8791 vn_cs_decoder_set_fatal(ctx->decoder);
8792 return;
8793 }
8794
8795 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8796 ctx->dispatch_vkDeviceWaitIdle(ctx, &args);
8797
8798 #ifdef DEBUG
8799 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
8800 vn_dispatch_debug_log(ctx, "vkDeviceWaitIdle returned %d", args.ret);
8801 #endif
8802
8803 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8804 vn_encode_vkDeviceWaitIdle_reply(ctx->encoder, &args);
8805
8806 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8807 }
8808
vn_dispatch_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8809 static inline void vn_dispatch_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8810 {
8811 struct vn_command_vkGetPhysicalDeviceSparseImageFormatProperties args;
8812
8813 if (!ctx->dispatch_vkGetPhysicalDeviceSparseImageFormatProperties) {
8814 vn_cs_decoder_set_fatal(ctx->decoder);
8815 return;
8816 }
8817
8818 vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties_args_temp(ctx->decoder, &args);
8819 if (!args.physicalDevice) {
8820 vn_cs_decoder_set_fatal(ctx->decoder);
8821 return;
8822 }
8823
8824 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8825 ctx->dispatch_vkGetPhysicalDeviceSparseImageFormatProperties(ctx, &args);
8826
8827
8828 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8829 vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties_reply(ctx->encoder, &args);
8830
8831 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8832 }
8833
vn_dispatch_vkGetPhysicalDeviceFeatures2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8834 static inline void vn_dispatch_vkGetPhysicalDeviceFeatures2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8835 {
8836 struct vn_command_vkGetPhysicalDeviceFeatures2 args;
8837
8838 if (!ctx->dispatch_vkGetPhysicalDeviceFeatures2) {
8839 vn_cs_decoder_set_fatal(ctx->decoder);
8840 return;
8841 }
8842
8843 vn_decode_vkGetPhysicalDeviceFeatures2_args_temp(ctx->decoder, &args);
8844 if (!args.physicalDevice) {
8845 vn_cs_decoder_set_fatal(ctx->decoder);
8846 return;
8847 }
8848
8849 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8850 ctx->dispatch_vkGetPhysicalDeviceFeatures2(ctx, &args);
8851
8852
8853 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8854 vn_encode_vkGetPhysicalDeviceFeatures2_reply(ctx->encoder, &args);
8855
8856 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8857 }
8858
vn_dispatch_vkGetPhysicalDeviceProperties2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8859 static inline void vn_dispatch_vkGetPhysicalDeviceProperties2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8860 {
8861 struct vn_command_vkGetPhysicalDeviceProperties2 args;
8862
8863 if (!ctx->dispatch_vkGetPhysicalDeviceProperties2) {
8864 vn_cs_decoder_set_fatal(ctx->decoder);
8865 return;
8866 }
8867
8868 vn_decode_vkGetPhysicalDeviceProperties2_args_temp(ctx->decoder, &args);
8869 if (!args.physicalDevice) {
8870 vn_cs_decoder_set_fatal(ctx->decoder);
8871 return;
8872 }
8873
8874 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8875 ctx->dispatch_vkGetPhysicalDeviceProperties2(ctx, &args);
8876
8877
8878 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8879 vn_encode_vkGetPhysicalDeviceProperties2_reply(ctx->encoder, &args);
8880
8881 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8882 }
8883
vn_dispatch_vkGetPhysicalDeviceFormatProperties2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8884 static inline void vn_dispatch_vkGetPhysicalDeviceFormatProperties2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8885 {
8886 struct vn_command_vkGetPhysicalDeviceFormatProperties2 args;
8887
8888 if (!ctx->dispatch_vkGetPhysicalDeviceFormatProperties2) {
8889 vn_cs_decoder_set_fatal(ctx->decoder);
8890 return;
8891 }
8892
8893 vn_decode_vkGetPhysicalDeviceFormatProperties2_args_temp(ctx->decoder, &args);
8894 if (!args.physicalDevice) {
8895 vn_cs_decoder_set_fatal(ctx->decoder);
8896 return;
8897 }
8898
8899 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8900 ctx->dispatch_vkGetPhysicalDeviceFormatProperties2(ctx, &args);
8901
8902
8903 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8904 vn_encode_vkGetPhysicalDeviceFormatProperties2_reply(ctx->encoder, &args);
8905
8906 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8907 }
8908
vn_dispatch_vkGetPhysicalDeviceImageFormatProperties2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8909 static inline void vn_dispatch_vkGetPhysicalDeviceImageFormatProperties2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8910 {
8911 struct vn_command_vkGetPhysicalDeviceImageFormatProperties2 args;
8912
8913 if (!ctx->dispatch_vkGetPhysicalDeviceImageFormatProperties2) {
8914 vn_cs_decoder_set_fatal(ctx->decoder);
8915 return;
8916 }
8917
8918 vn_decode_vkGetPhysicalDeviceImageFormatProperties2_args_temp(ctx->decoder, &args);
8919 if (!args.physicalDevice) {
8920 vn_cs_decoder_set_fatal(ctx->decoder);
8921 return;
8922 }
8923
8924 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8925 ctx->dispatch_vkGetPhysicalDeviceImageFormatProperties2(ctx, &args);
8926
8927 #ifdef DEBUG
8928 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
8929 vn_dispatch_debug_log(ctx, "vkGetPhysicalDeviceImageFormatProperties2 returned %d", args.ret);
8930 #endif
8931
8932 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8933 vn_encode_vkGetPhysicalDeviceImageFormatProperties2_reply(ctx->encoder, &args);
8934
8935 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8936 }
8937
vn_dispatch_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8938 static inline void vn_dispatch_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8939 {
8940 struct vn_command_vkGetPhysicalDeviceQueueFamilyProperties2 args;
8941
8942 if (!ctx->dispatch_vkGetPhysicalDeviceQueueFamilyProperties2) {
8943 vn_cs_decoder_set_fatal(ctx->decoder);
8944 return;
8945 }
8946
8947 vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_args_temp(ctx->decoder, &args);
8948 if (!args.physicalDevice) {
8949 vn_cs_decoder_set_fatal(ctx->decoder);
8950 return;
8951 }
8952
8953 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8954 ctx->dispatch_vkGetPhysicalDeviceQueueFamilyProperties2(ctx, &args);
8955
8956
8957 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8958 vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(ctx->encoder, &args);
8959
8960 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8961 }
8962
vn_dispatch_vkGetPhysicalDeviceMemoryProperties2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8963 static inline void vn_dispatch_vkGetPhysicalDeviceMemoryProperties2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8964 {
8965 struct vn_command_vkGetPhysicalDeviceMemoryProperties2 args;
8966
8967 if (!ctx->dispatch_vkGetPhysicalDeviceMemoryProperties2) {
8968 vn_cs_decoder_set_fatal(ctx->decoder);
8969 return;
8970 }
8971
8972 vn_decode_vkGetPhysicalDeviceMemoryProperties2_args_temp(ctx->decoder, &args);
8973 if (!args.physicalDevice) {
8974 vn_cs_decoder_set_fatal(ctx->decoder);
8975 return;
8976 }
8977
8978 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8979 ctx->dispatch_vkGetPhysicalDeviceMemoryProperties2(ctx, &args);
8980
8981
8982 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8983 vn_encode_vkGetPhysicalDeviceMemoryProperties2_reply(ctx->encoder, &args);
8984
8985 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8986 }
8987
vn_dispatch_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8988 static inline void vn_dispatch_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8989 {
8990 struct vn_command_vkGetPhysicalDeviceSparseImageFormatProperties2 args;
8991
8992 if (!ctx->dispatch_vkGetPhysicalDeviceSparseImageFormatProperties2) {
8993 vn_cs_decoder_set_fatal(ctx->decoder);
8994 return;
8995 }
8996
8997 vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_args_temp(ctx->decoder, &args);
8998 if (!args.physicalDevice) {
8999 vn_cs_decoder_set_fatal(ctx->decoder);
9000 return;
9001 }
9002
9003 if (!vn_cs_decoder_get_fatal(ctx->decoder))
9004 ctx->dispatch_vkGetPhysicalDeviceSparseImageFormatProperties2(ctx, &args);
9005
9006
9007 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
9008 vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(ctx->encoder, &args);
9009
9010 vn_cs_decoder_reset_temp_pool(ctx->decoder);
9011 }
9012
vn_dispatch_vkGetPhysicalDeviceExternalBufferProperties(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)9013 static inline void vn_dispatch_vkGetPhysicalDeviceExternalBufferProperties(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
9014 {
9015 struct vn_command_vkGetPhysicalDeviceExternalBufferProperties args;
9016
9017 if (!ctx->dispatch_vkGetPhysicalDeviceExternalBufferProperties) {
9018 vn_cs_decoder_set_fatal(ctx->decoder);
9019 return;
9020 }
9021
9022 vn_decode_vkGetPhysicalDeviceExternalBufferProperties_args_temp(ctx->decoder, &args);
9023 if (!args.physicalDevice) {
9024 vn_cs_decoder_set_fatal(ctx->decoder);
9025 return;
9026 }
9027
9028 if (!vn_cs_decoder_get_fatal(ctx->decoder))
9029 ctx->dispatch_vkGetPhysicalDeviceExternalBufferProperties(ctx, &args);
9030
9031
9032 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
9033 vn_encode_vkGetPhysicalDeviceExternalBufferProperties_reply(ctx->encoder, &args);
9034
9035 vn_cs_decoder_reset_temp_pool(ctx->decoder);
9036 }
9037
vn_dispatch_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)9038 static inline void vn_dispatch_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
9039 {
9040 struct vn_command_vkGetPhysicalDeviceExternalSemaphoreProperties args;
9041
9042 if (!ctx->dispatch_vkGetPhysicalDeviceExternalSemaphoreProperties) {
9043 vn_cs_decoder_set_fatal(ctx->decoder);
9044 return;
9045 }
9046
9047 vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_args_temp(ctx->decoder, &args);
9048 if (!args.physicalDevice) {
9049 vn_cs_decoder_set_fatal(ctx->decoder);
9050 return;
9051 }
9052
9053 if (!vn_cs_decoder_get_fatal(ctx->decoder))
9054 ctx->dispatch_vkGetPhysicalDeviceExternalSemaphoreProperties(ctx, &args);
9055
9056
9057 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
9058 vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(ctx->encoder, &args);
9059
9060 vn_cs_decoder_reset_temp_pool(ctx->decoder);
9061 }
9062
vn_dispatch_vkGetPhysicalDeviceExternalFenceProperties(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)9063 static inline void vn_dispatch_vkGetPhysicalDeviceExternalFenceProperties(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
9064 {
9065 struct vn_command_vkGetPhysicalDeviceExternalFenceProperties args;
9066
9067 if (!ctx->dispatch_vkGetPhysicalDeviceExternalFenceProperties) {
9068 vn_cs_decoder_set_fatal(ctx->decoder);
9069 return;
9070 }
9071
9072 vn_decode_vkGetPhysicalDeviceExternalFenceProperties_args_temp(ctx->decoder, &args);
9073 if (!args.physicalDevice) {
9074 vn_cs_decoder_set_fatal(ctx->decoder);
9075 return;
9076 }
9077
9078 if (!vn_cs_decoder_get_fatal(ctx->decoder))
9079 ctx->dispatch_vkGetPhysicalDeviceExternalFenceProperties(ctx, &args);
9080
9081
9082 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
9083 vn_encode_vkGetPhysicalDeviceExternalFenceProperties_reply(ctx->encoder, &args);
9084
9085 vn_cs_decoder_reset_temp_pool(ctx->decoder);
9086 }
9087
vn_dispatch_vkEnumeratePhysicalDeviceGroups(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)9088 static inline void vn_dispatch_vkEnumeratePhysicalDeviceGroups(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
9089 {
9090 struct vn_command_vkEnumeratePhysicalDeviceGroups args;
9091
9092 if (!ctx->dispatch_vkEnumeratePhysicalDeviceGroups) {
9093 vn_cs_decoder_set_fatal(ctx->decoder);
9094 return;
9095 }
9096
9097 vn_decode_vkEnumeratePhysicalDeviceGroups_args_temp(ctx->decoder, &args);
9098 if (!args.instance) {
9099 vn_cs_decoder_set_fatal(ctx->decoder);
9100 return;
9101 }
9102
9103 if (!vn_cs_decoder_get_fatal(ctx->decoder))
9104 ctx->dispatch_vkEnumeratePhysicalDeviceGroups(ctx, &args);
9105
9106 #ifdef DEBUG
9107 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
9108 vn_dispatch_debug_log(ctx, "vkEnumeratePhysicalDeviceGroups returned %d", args.ret);
9109 #endif
9110
9111 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
9112 vn_encode_vkEnumeratePhysicalDeviceGroups_reply(ctx->encoder, &args);
9113
9114 vn_cs_decoder_reset_temp_pool(ctx->decoder);
9115 }
9116
vn_dispatch_vkGetDeviceGroupPeerMemoryFeatures(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)9117 static inline void vn_dispatch_vkGetDeviceGroupPeerMemoryFeatures(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
9118 {
9119 struct vn_command_vkGetDeviceGroupPeerMemoryFeatures args;
9120
9121 if (!ctx->dispatch_vkGetDeviceGroupPeerMemoryFeatures) {
9122 vn_cs_decoder_set_fatal(ctx->decoder);
9123 return;
9124 }
9125
9126 vn_decode_vkGetDeviceGroupPeerMemoryFeatures_args_temp(ctx->decoder, &args);
9127 if (!args.device) {
9128 vn_cs_decoder_set_fatal(ctx->decoder);
9129 return;
9130 }
9131
9132 if (!vn_cs_decoder_get_fatal(ctx->decoder))
9133 ctx->dispatch_vkGetDeviceGroupPeerMemoryFeatures(ctx, &args);
9134
9135
9136 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
9137 vn_encode_vkGetDeviceGroupPeerMemoryFeatures_reply(ctx->encoder, &args);
9138
9139 vn_cs_decoder_reset_temp_pool(ctx->decoder);
9140 }
9141
vn_dispatch_vkGetDeviceQueue2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)9142 static inline void vn_dispatch_vkGetDeviceQueue2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
9143 {
9144 struct vn_command_vkGetDeviceQueue2 args;
9145
9146 if (!ctx->dispatch_vkGetDeviceQueue2) {
9147 vn_cs_decoder_set_fatal(ctx->decoder);
9148 return;
9149 }
9150
9151 vn_decode_vkGetDeviceQueue2_args_temp(ctx->decoder, &args);
9152 if (!args.device) {
9153 vn_cs_decoder_set_fatal(ctx->decoder);
9154 return;
9155 }
9156
9157 if (!vn_cs_decoder_get_fatal(ctx->decoder))
9158 ctx->dispatch_vkGetDeviceQueue2(ctx, &args);
9159
9160
9161 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
9162 vn_encode_vkGetDeviceQueue2_reply(ctx->encoder, &args);
9163
9164 vn_cs_decoder_reset_temp_pool(ctx->decoder);
9165 }
9166
9167 #pragma GCC diagnostic pop
9168
9169 #endif /* VN_PROTOCOL_RENDERER_DEVICE_H */
9170