dlls/winevulkan/vulkan_thunks.c

   1 /* Automatically generated from Vulkan vk.xml; DO NOT EDIT!
   2  *
   3  * This file is generated from Vulkan vk.xml file covered
   4  * by the following copyright and permission notice:
   5  *
   6  * Copyright 2015-2022 The Khronos Group Inc.
   7  *
   8  * SPDX-License-Identifier: Apache-2.0 OR MIT
   9  *
  10  */
  11
  12 #if 0
  13 #pragma makedep unix
  14 #endif
  15
  16 #include "config.h"
  17
  18 #include <stdlib.h>
  19
  20 #include "vulkan_private.h"
  21
  22 WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
  23
  24 #if defined(USE_STRUCT_CONVERSION)
  25
  26 typedef struct VkAcquireNextImageInfoKHR32
  27 {
  28     VkStructureType sType;
  29     const void *pNext;
  30     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
  31     uint64_t DECLSPEC_ALIGN(8) timeout;
  32     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
  33     VkFence DECLSPEC_ALIGN(8) fence;
  34     uint32_t deviceMask;
  35 } VkAcquireNextImageInfoKHR32;
  36
  37 typedef struct VkPerformanceConfigurationAcquireInfoINTEL32
  38 {
  39     VkStructureType sType;
  40     const void *pNext;
  41     VkPerformanceConfigurationTypeINTEL type;
  42 } VkPerformanceConfigurationAcquireInfoINTEL32;
  43
  44 typedef struct VkAcquireProfilingLockInfoKHR32
  45 {
  46     VkStructureType sType;
  47     const void *pNext;
  48     VkAcquireProfilingLockFlagsKHR flags;
  49     uint64_t DECLSPEC_ALIGN(8) timeout;
  50 } VkAcquireProfilingLockInfoKHR32;
  51
  52 typedef struct VkCommandBufferAllocateInfo32
  53 {
  54     VkStructureType sType;
  55     const void *pNext;
  56     VkCommandPool DECLSPEC_ALIGN(8) commandPool;
  57     VkCommandBufferLevel level;
  58     uint32_t commandBufferCount;
  59 } VkCommandBufferAllocateInfo32;
  60
  61 typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo32
  62 {
  63     VkStructureType sType;
  64     const void *pNext;
  65     uint32_t descriptorSetCount;
  66     const uint32_t *pDescriptorCounts;
  67 } VkDescriptorSetVariableDescriptorCountAllocateInfo32;
  68 typedef VkDescriptorSetVariableDescriptorCountAllocateInfo32 VkDescriptorSetVariableDescriptorCountAllocateInfoEXT32;
  69
  70 typedef struct VkDescriptorSetAllocateInfo32
  71 {
  72     VkStructureType sType;
  73     const void *pNext;
  74     VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
  75     uint32_t descriptorSetCount;
  76     const VkDescriptorSetLayout *pSetLayouts;
  77 } VkDescriptorSetAllocateInfo32;
  78
  79 typedef struct VkDedicatedAllocationMemoryAllocateInfoNV32
  80 {
  81     VkStructureType sType;
  82     const void *pNext;
  83     VkImage DECLSPEC_ALIGN(8) image;
  84     VkBuffer DECLSPEC_ALIGN(8) buffer;
  85 } VkDedicatedAllocationMemoryAllocateInfoNV32;
  86
  87 typedef struct VkExportMemoryAllocateInfo32
  88 {
  89     VkStructureType sType;
  90     const void *pNext;
  91     VkExternalMemoryHandleTypeFlags handleTypes;
  92 } VkExportMemoryAllocateInfo32;
  93 typedef VkExportMemoryAllocateInfo32 VkExportMemoryAllocateInfoKHR32;
  94
  95 typedef struct VkImportMemoryWin32HandleInfoKHR32
  96 {
  97     VkStructureType sType;
  98     const void *pNext;
  99     VkExternalMemoryHandleTypeFlagBits handleType;
 100     HANDLE handle;
 101     LPCWSTR name;
 102 } VkImportMemoryWin32HandleInfoKHR32;
 103
 104 typedef struct VkExportMemoryWin32HandleInfoKHR32
 105 {
 106     VkStructureType sType;
 107     const void *pNext;
 108     const SECURITY_ATTRIBUTES *pAttributes;
 109     DWORD dwAccess;
 110     LPCWSTR name;
 111 } VkExportMemoryWin32HandleInfoKHR32;
 112
 113 typedef struct VkMemoryAllocateFlagsInfo32
 114 {
 115     VkStructureType sType;
 116     const void *pNext;
 117     VkMemoryAllocateFlags flags;
 118     uint32_t deviceMask;
 119 } VkMemoryAllocateFlagsInfo32;
 120 typedef VkMemoryAllocateFlagsInfo32 VkMemoryAllocateFlagsInfoKHR32;
 121
 122 typedef struct VkMemoryDedicatedAllocateInfo32
 123 {
 124     VkStructureType sType;
 125     const void *pNext;
 126     VkImage DECLSPEC_ALIGN(8) image;
 127     VkBuffer DECLSPEC_ALIGN(8) buffer;
 128 } VkMemoryDedicatedAllocateInfo32;
 129 typedef VkMemoryDedicatedAllocateInfo32 VkMemoryDedicatedAllocateInfoKHR32;
 130
 131 typedef struct VkImportMemoryHostPointerInfoEXT32
 132 {
 133     VkStructureType sType;
 134     const void *pNext;
 135     VkExternalMemoryHandleTypeFlagBits handleType;
 136     void *pHostPointer;
 137 } VkImportMemoryHostPointerInfoEXT32;
 138
 139 typedef struct VkMemoryPriorityAllocateInfoEXT32
 140 {
 141     VkStructureType sType;
 142     const void *pNext;
 143     float priority;
 144 } VkMemoryPriorityAllocateInfoEXT32;
 145
 146 typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo32
 147 {
 148     VkStructureType sType;
 149     const void *pNext;
 150     uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress;
 151 } VkMemoryOpaqueCaptureAddressAllocateInfo32;
 152 typedef VkMemoryOpaqueCaptureAddressAllocateInfo32 VkMemoryOpaqueCaptureAddressAllocateInfoKHR32;
 153
 154 typedef struct VkMemoryAllocateInfo32
 155 {
 156     VkStructureType sType;
 157     const void *pNext;
 158     VkDeviceSize DECLSPEC_ALIGN(8) allocationSize;
 159     uint32_t memoryTypeIndex;
 160 } VkMemoryAllocateInfo32;
 161
 162 typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT32
 163 {
 164     VkStructureType sType;
 165     const void *pNext;
 166     VkBool32 conditionalRenderingEnable;
 167 } VkCommandBufferInheritanceConditionalRenderingInfoEXT32;
 168
 169 typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM32
 170 {
 171     VkStructureType sType;
 172     void *pNext;
 173     VkSurfaceTransformFlagBitsKHR transform;
 174     VkRect2D renderArea;
 175 } VkCommandBufferInheritanceRenderPassTransformInfoQCOM32;
 176
 177 typedef struct VkCommandBufferInheritanceViewportScissorInfoNV32
 178 {
 179     VkStructureType sType;
 180     const void *pNext;
 181     VkBool32 viewportScissor2D;
 182     uint32_t viewportDepthCount;
 183     const VkViewport *pViewportDepths;
 184 } VkCommandBufferInheritanceViewportScissorInfoNV32;
 185
 186 typedef struct VkCommandBufferInheritanceRenderingInfo32
 187 {
 188     VkStructureType sType;
 189     const void *pNext;
 190     VkRenderingFlags flags;
 191     uint32_t viewMask;
 192     uint32_t colorAttachmentCount;
 193     const VkFormat *pColorAttachmentFormats;
 194     VkFormat depthAttachmentFormat;
 195     VkFormat stencilAttachmentFormat;
 196     VkSampleCountFlagBits rasterizationSamples;
 197 } VkCommandBufferInheritanceRenderingInfo32;
 198 typedef VkCommandBufferInheritanceRenderingInfo32 VkCommandBufferInheritanceRenderingInfoKHR32;
 199
 200 typedef struct VkAttachmentSampleCountInfoAMD32
 201 {
 202     VkStructureType sType;
 203     const void *pNext;
 204     uint32_t colorAttachmentCount;
 205     const VkSampleCountFlagBits *pColorAttachmentSamples;
 206     VkSampleCountFlagBits depthStencilAttachmentSamples;
 207 } VkAttachmentSampleCountInfoAMD32;
 208 typedef VkAttachmentSampleCountInfoAMD32 VkAttachmentSampleCountInfoNV32;
 209
 210 typedef struct VkMultiviewPerViewAttributesInfoNVX32
 211 {
 212     VkStructureType sType;
 213     const void *pNext;
 214     VkBool32 perViewAttributes;
 215     VkBool32 perViewAttributesPositionXOnly;
 216 } VkMultiviewPerViewAttributesInfoNVX32;
 217
 218 typedef struct VkCommandBufferInheritanceInfo32
 219 {
 220     VkStructureType sType;
 221     const void *pNext;
 222     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
 223     uint32_t subpass;
 224     VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
 225     VkBool32 occlusionQueryEnable;
 226     VkQueryControlFlags queryFlags;
 227     VkQueryPipelineStatisticFlags pipelineStatistics;
 228 } VkCommandBufferInheritanceInfo32;
 229
 230 typedef struct VkDeviceGroupCommandBufferBeginInfo32
 231 {
 232     VkStructureType sType;
 233     const void *pNext;
 234     uint32_t deviceMask;
 235 } VkDeviceGroupCommandBufferBeginInfo32;
 236 typedef VkDeviceGroupCommandBufferBeginInfo32 VkDeviceGroupCommandBufferBeginInfoKHR32;
 237
 238 typedef struct VkCommandBufferBeginInfo32
 239 {
 240     VkStructureType sType;
 241     const void *pNext;
 242     VkCommandBufferUsageFlags flags;
 243     const VkCommandBufferInheritanceInfo32 *pInheritanceInfo;
 244 } VkCommandBufferBeginInfo32;
 245
 246 typedef struct VkBindAccelerationStructureMemoryInfoNV32
 247 {
 248     VkStructureType sType;
 249     const void *pNext;
 250     VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
 251     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
 252     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
 253     uint32_t deviceIndexCount;
 254     const uint32_t *pDeviceIndices;
 255 } VkBindAccelerationStructureMemoryInfoNV32;
 256
 257 typedef struct VkBindBufferMemoryDeviceGroupInfo32
 258 {
 259     VkStructureType sType;
 260     const void *pNext;
 261     uint32_t deviceIndexCount;
 262     const uint32_t *pDeviceIndices;
 263 } VkBindBufferMemoryDeviceGroupInfo32;
 264 typedef VkBindBufferMemoryDeviceGroupInfo32 VkBindBufferMemoryDeviceGroupInfoKHR32;
 265
 266 typedef struct VkBindBufferMemoryInfo32
 267 {
 268     VkStructureType sType;
 269     const void *pNext;
 270     VkBuffer DECLSPEC_ALIGN(8) buffer;
 271     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
 272     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
 273 } VkBindBufferMemoryInfo32;
 274 typedef VkBindBufferMemoryInfo32 VkBindBufferMemoryInfoKHR32;
 275
 276 typedef struct VkBindImageMemoryDeviceGroupInfo32
 277 {
 278     VkStructureType sType;
 279     const void *pNext;
 280     uint32_t deviceIndexCount;
 281     const uint32_t *pDeviceIndices;
 282     uint32_t splitInstanceBindRegionCount;
 283     const VkRect2D *pSplitInstanceBindRegions;
 284 } VkBindImageMemoryDeviceGroupInfo32;
 285 typedef VkBindImageMemoryDeviceGroupInfo32 VkBindImageMemoryDeviceGroupInfoKHR32;
 286
 287 typedef struct VkBindImageMemorySwapchainInfoKHR32
 288 {
 289     VkStructureType sType;
 290     const void *pNext;
 291     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
 292     uint32_t imageIndex;
 293 } VkBindImageMemorySwapchainInfoKHR32;
 294
 295 typedef struct VkBindImagePlaneMemoryInfo32
 296 {
 297     VkStructureType sType;
 298     const void *pNext;
 299     VkImageAspectFlagBits planeAspect;
 300 } VkBindImagePlaneMemoryInfo32;
 301 typedef VkBindImagePlaneMemoryInfo32 VkBindImagePlaneMemoryInfoKHR32;
 302
 303 typedef struct VkBindImageMemoryInfo32
 304 {
 305     VkStructureType sType;
 306     const void *pNext;
 307     VkImage DECLSPEC_ALIGN(8) image;
 308     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
 309     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
 310 } VkBindImageMemoryInfo32;
 311 typedef VkBindImageMemoryInfo32 VkBindImageMemoryInfoKHR32;
 312
 313 typedef struct VkAccelerationStructureGeometryKHR32
 314 {
 315     VkStructureType sType;
 316     const void *pNext;
 317     VkGeometryTypeKHR geometryType;
 318     VkAccelerationStructureGeometryDataKHR DECLSPEC_ALIGN(8) geometry;
 319     VkGeometryFlagsKHR flags;
 320 } VkAccelerationStructureGeometryKHR32;
 321
 322 typedef struct VkAccelerationStructureBuildGeometryInfoKHR32
 323 {
 324     VkStructureType sType;
 325     const void *pNext;
 326     VkAccelerationStructureTypeKHR type;
 327     VkBuildAccelerationStructureFlagsKHR flags;
 328     VkBuildAccelerationStructureModeKHR mode;
 329     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) srcAccelerationStructure;
 330     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dstAccelerationStructure;
 331     uint32_t geometryCount;
 332     const VkAccelerationStructureGeometryKHR32 *pGeometries;
 333     const VkAccelerationStructureGeometryKHR32 * const*ppGeometries;
 334     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData;
 335 } VkAccelerationStructureBuildGeometryInfoKHR32;
 336
 337 typedef struct VkMicromapBuildInfoEXT32
 338 {
 339     VkStructureType sType;
 340     const void *pNext;
 341     VkMicromapTypeEXT type;
 342     VkBuildMicromapFlagsEXT flags;
 343     VkBuildMicromapModeEXT mode;
 344     VkMicromapEXT DECLSPEC_ALIGN(8) dstMicromap;
 345     uint32_t usageCountsCount;
 346     const VkMicromapUsageEXT *pUsageCounts;
 347     const VkMicromapUsageEXT * const*ppUsageCounts;
 348     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data;
 349     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData;
 350     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) triangleArray;
 351     VkDeviceSize DECLSPEC_ALIGN(8) triangleArrayStride;
 352 } VkMicromapBuildInfoEXT32;
 353
 354 typedef struct VkConditionalRenderingBeginInfoEXT32
 355 {
 356     VkStructureType sType;
 357     const void *pNext;
 358     VkBuffer DECLSPEC_ALIGN(8) buffer;
 359     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 360     VkConditionalRenderingFlagsEXT flags;
 361 } VkConditionalRenderingBeginInfoEXT32;
 362
 363 typedef struct VkDebugUtilsLabelEXT32
 364 {
 365     VkStructureType sType;
 366     const void *pNext;
 367     const char *pLabelName;
 368     float color[4];
 369 } VkDebugUtilsLabelEXT32;
 370
 371 typedef struct VkSampleLocationsInfoEXT32
 372 {
 373     VkStructureType sType;
 374     const void *pNext;
 375     VkSampleCountFlagBits sampleLocationsPerPixel;
 376     VkExtent2D sampleLocationGridSize;
 377     uint32_t sampleLocationsCount;
 378     const VkSampleLocationEXT *pSampleLocations;
 379 } VkSampleLocationsInfoEXT32;
 380
 381 typedef struct VkAttachmentSampleLocationsEXT32
 382 {
 383     uint32_t attachmentIndex;
 384     VkSampleLocationsInfoEXT32 sampleLocationsInfo;
 385 } VkAttachmentSampleLocationsEXT32;
 386
 387 typedef struct VkSubpassSampleLocationsEXT32
 388 {
 389     uint32_t subpassIndex;
 390     VkSampleLocationsInfoEXT32 sampleLocationsInfo;
 391 } VkSubpassSampleLocationsEXT32;
 392
 393 typedef struct VkDeviceGroupRenderPassBeginInfo32
 394 {
 395     VkStructureType sType;
 396     const void *pNext;
 397     uint32_t deviceMask;
 398     uint32_t deviceRenderAreaCount;
 399     const VkRect2D *pDeviceRenderAreas;
 400 } VkDeviceGroupRenderPassBeginInfo32;
 401 typedef VkDeviceGroupRenderPassBeginInfo32 VkDeviceGroupRenderPassBeginInfoKHR32;
 402
 403 typedef struct VkRenderPassSampleLocationsBeginInfoEXT32
 404 {
 405     VkStructureType sType;
 406     const void *pNext;
 407     uint32_t attachmentInitialSampleLocationsCount;
 408     const VkAttachmentSampleLocationsEXT32 *pAttachmentInitialSampleLocations;
 409     uint32_t postSubpassSampleLocationsCount;
 410     const VkSubpassSampleLocationsEXT32 *pPostSubpassSampleLocations;
 411 } VkRenderPassSampleLocationsBeginInfoEXT32;
 412
 413 typedef struct VkRenderPassAttachmentBeginInfo32
 414 {
 415     VkStructureType sType;
 416     const void *pNext;
 417     uint32_t attachmentCount;
 418     const VkImageView *pAttachments;
 419 } VkRenderPassAttachmentBeginInfo32;
 420 typedef VkRenderPassAttachmentBeginInfo32 VkRenderPassAttachmentBeginInfoKHR32;
 421
 422 typedef struct VkRenderPassTransformBeginInfoQCOM32
 423 {
 424     VkStructureType sType;
 425     void *pNext;
 426     VkSurfaceTransformFlagBitsKHR transform;
 427 } VkRenderPassTransformBeginInfoQCOM32;
 428
 429 typedef struct VkRenderPassBeginInfo32
 430 {
 431     VkStructureType sType;
 432     const void *pNext;
 433     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
 434     VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
 435     VkRect2D renderArea;
 436     uint32_t clearValueCount;
 437     const VkClearValue *pClearValues;
 438 } VkRenderPassBeginInfo32;
 439
 440 typedef struct VkSubpassBeginInfo32
 441 {
 442     VkStructureType sType;
 443     const void *pNext;
 444     VkSubpassContents contents;
 445 } VkSubpassBeginInfo32;
 446 typedef VkSubpassBeginInfo32 VkSubpassBeginInfoKHR32;
 447
 448 typedef struct VkRenderingAttachmentInfo32
 449 {
 450     VkStructureType sType;
 451     const void *pNext;
 452     VkImageView DECLSPEC_ALIGN(8) imageView;
 453     VkImageLayout imageLayout;
 454     VkResolveModeFlagBits resolveMode;
 455     VkImageView DECLSPEC_ALIGN(8) resolveImageView;
 456     VkImageLayout resolveImageLayout;
 457     VkAttachmentLoadOp loadOp;
 458     VkAttachmentStoreOp storeOp;
 459     VkClearValue clearValue;
 460 } VkRenderingAttachmentInfo32;
 461 typedef VkRenderingAttachmentInfo32 VkRenderingAttachmentInfoKHR32;
 462
 463 typedef struct VkMultisampledRenderToSingleSampledInfoEXT32
 464 {
 465     VkStructureType sType;
 466     const void *pNext;
 467     VkBool32 multisampledRenderToSingleSampledEnable;
 468     VkSampleCountFlagBits rasterizationSamples;
 469 } VkMultisampledRenderToSingleSampledInfoEXT32;
 470
 471 typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR32
 472 {
 473     VkStructureType sType;
 474     const void *pNext;
 475     VkImageView DECLSPEC_ALIGN(8) imageView;
 476     VkImageLayout imageLayout;
 477     VkExtent2D shadingRateAttachmentTexelSize;
 478 } VkRenderingFragmentShadingRateAttachmentInfoKHR32;
 479
 480 typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT32
 481 {
 482     VkStructureType sType;
 483     const void *pNext;
 484     VkImageView DECLSPEC_ALIGN(8) imageView;
 485     VkImageLayout imageLayout;
 486 } VkRenderingFragmentDensityMapAttachmentInfoEXT32;
 487
 488 typedef struct VkRenderingInfo32
 489 {
 490     VkStructureType sType;
 491     const void *pNext;
 492     VkRenderingFlags flags;
 493     VkRect2D renderArea;
 494     uint32_t layerCount;
 495     uint32_t viewMask;
 496     uint32_t colorAttachmentCount;
 497     const VkRenderingAttachmentInfo32 *pColorAttachments;
 498     const VkRenderingAttachmentInfo32 *pDepthAttachment;
 499     const VkRenderingAttachmentInfo32 *pStencilAttachment;
 500 } VkRenderingInfo32;
 501 typedef VkRenderingInfo32 VkRenderingInfoKHR32;
 502
 503 typedef struct VkCopyCommandTransformInfoQCOM32
 504 {
 505     VkStructureType sType;
 506     const void *pNext;
 507     VkSurfaceTransformFlagBitsKHR transform;
 508 } VkCopyCommandTransformInfoQCOM32;
 509
 510 typedef struct VkImageBlit232
 511 {
 512     VkStructureType sType;
 513     const void *pNext;
 514     VkImageSubresourceLayers srcSubresource;
 515     VkOffset3D srcOffsets[2];
 516     VkImageSubresourceLayers dstSubresource;
 517     VkOffset3D dstOffsets[2];
 518 } VkImageBlit232;
 519 typedef VkImageBlit232 VkImageBlit2KHR32;
 520
 521 typedef struct VkBlitImageInfo232
 522 {
 523     VkStructureType sType;
 524     const void *pNext;
 525     VkImage DECLSPEC_ALIGN(8) srcImage;
 526     VkImageLayout srcImageLayout;
 527     VkImage DECLSPEC_ALIGN(8) dstImage;
 528     VkImageLayout dstImageLayout;
 529     uint32_t regionCount;
 530     const VkImageBlit232 *pRegions;
 531     VkFilter filter;
 532 } VkBlitImageInfo232;
 533 typedef VkBlitImageInfo232 VkBlitImageInfo2KHR32;
 534
 535 typedef struct VkGeometryTrianglesNV32
 536 {
 537     VkStructureType sType;
 538     const void *pNext;
 539     VkBuffer DECLSPEC_ALIGN(8) vertexData;
 540     VkDeviceSize DECLSPEC_ALIGN(8) vertexOffset;
 541     uint32_t vertexCount;
 542     VkDeviceSize DECLSPEC_ALIGN(8) vertexStride;
 543     VkFormat vertexFormat;
 544     VkBuffer DECLSPEC_ALIGN(8) indexData;
 545     VkDeviceSize DECLSPEC_ALIGN(8) indexOffset;
 546     uint32_t indexCount;
 547     VkIndexType indexType;
 548     VkBuffer DECLSPEC_ALIGN(8) transformData;
 549     VkDeviceSize DECLSPEC_ALIGN(8) transformOffset;
 550 } VkGeometryTrianglesNV32;
 551
 552 typedef struct VkGeometryAABBNV32
 553 {
 554     VkStructureType sType;
 555     const void *pNext;
 556     VkBuffer DECLSPEC_ALIGN(8) aabbData;
 557     uint32_t numAABBs;
 558     uint32_t stride;
 559     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 560 } VkGeometryAABBNV32;
 561
 562 typedef struct VkGeometryDataNV32
 563 {
 564     VkGeometryTrianglesNV32 DECLSPEC_ALIGN(8) triangles;
 565     VkGeometryAABBNV32 DECLSPEC_ALIGN(8) aabbs;
 566 } VkGeometryDataNV32;
 567
 568 typedef struct VkGeometryNV32
 569 {
 570     VkStructureType sType;
 571     const void *pNext;
 572     VkGeometryTypeKHR geometryType;
 573     VkGeometryDataNV32 DECLSPEC_ALIGN(8) geometry;
 574     VkGeometryFlagsKHR flags;
 575 } VkGeometryNV32;
 576
 577 typedef struct VkAccelerationStructureInfoNV32
 578 {
 579     VkStructureType sType;
 580     const void *pNext;
 581     VkAccelerationStructureTypeNV type;
 582     VkBuildAccelerationStructureFlagsNV flags;
 583     uint32_t instanceCount;
 584     uint32_t geometryCount;
 585     const VkGeometryNV32 *pGeometries;
 586 } VkAccelerationStructureInfoNV32;
 587
 588 typedef struct VkCopyAccelerationStructureInfoKHR32
 589 {
 590     VkStructureType sType;
 591     const void *pNext;
 592     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src;
 593     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst;
 594     VkCopyAccelerationStructureModeKHR mode;
 595 } VkCopyAccelerationStructureInfoKHR32;
 596
 597 typedef struct VkCopyAccelerationStructureToMemoryInfoKHR32
 598 {
 599     VkStructureType sType;
 600     const void *pNext;
 601     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src;
 602     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst;
 603     VkCopyAccelerationStructureModeKHR mode;
 604 } VkCopyAccelerationStructureToMemoryInfoKHR32;
 605
 606 typedef struct VkBufferCopy32
 607 {
 608     VkDeviceSize DECLSPEC_ALIGN(8) srcOffset;
 609     VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
 610     VkDeviceSize DECLSPEC_ALIGN(8) size;
 611 } VkBufferCopy32;
 612
 613 typedef struct VkBufferCopy232
 614 {
 615     VkStructureType sType;
 616     const void *pNext;
 617     VkDeviceSize DECLSPEC_ALIGN(8) srcOffset;
 618     VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
 619     VkDeviceSize DECLSPEC_ALIGN(8) size;
 620 } VkBufferCopy232;
 621 typedef VkBufferCopy232 VkBufferCopy2KHR32;
 622
 623 typedef struct VkCopyBufferInfo232
 624 {
 625     VkStructureType sType;
 626     const void *pNext;
 627     VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
 628     VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
 629     uint32_t regionCount;
 630     const VkBufferCopy232 *pRegions;
 631 } VkCopyBufferInfo232;
 632 typedef VkCopyBufferInfo232 VkCopyBufferInfo2KHR32;
 633
 634 typedef struct VkBufferImageCopy32
 635 {
 636     VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset;
 637     uint32_t bufferRowLength;
 638     uint32_t bufferImageHeight;
 639     VkImageSubresourceLayers imageSubresource;
 640     VkOffset3D imageOffset;
 641     VkExtent3D imageExtent;
 642 } VkBufferImageCopy32;
 643
 644 typedef struct VkBufferImageCopy232
 645 {
 646     VkStructureType sType;
 647     const void *pNext;
 648     VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset;
 649     uint32_t bufferRowLength;
 650     uint32_t bufferImageHeight;
 651     VkImageSubresourceLayers imageSubresource;
 652     VkOffset3D imageOffset;
 653     VkExtent3D imageExtent;
 654 } VkBufferImageCopy232;
 655 typedef VkBufferImageCopy232 VkBufferImageCopy2KHR32;
 656
 657 typedef struct VkCopyBufferToImageInfo232
 658 {
 659     VkStructureType sType;
 660     const void *pNext;
 661     VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
 662     VkImage DECLSPEC_ALIGN(8) dstImage;
 663     VkImageLayout dstImageLayout;
 664     uint32_t regionCount;
 665     const VkBufferImageCopy232 *pRegions;
 666 } VkCopyBufferToImageInfo232;
 667 typedef VkCopyBufferToImageInfo232 VkCopyBufferToImageInfo2KHR32;
 668
 669 typedef struct VkImageCopy232
 670 {
 671     VkStructureType sType;
 672     const void *pNext;
 673     VkImageSubresourceLayers srcSubresource;
 674     VkOffset3D srcOffset;
 675     VkImageSubresourceLayers dstSubresource;
 676     VkOffset3D dstOffset;
 677     VkExtent3D extent;
 678 } VkImageCopy232;
 679 typedef VkImageCopy232 VkImageCopy2KHR32;
 680
 681 typedef struct VkCopyImageInfo232
 682 {
 683     VkStructureType sType;
 684     const void *pNext;
 685     VkImage DECLSPEC_ALIGN(8) srcImage;
 686     VkImageLayout srcImageLayout;
 687     VkImage DECLSPEC_ALIGN(8) dstImage;
 688     VkImageLayout dstImageLayout;
 689     uint32_t regionCount;
 690     const VkImageCopy232 *pRegions;
 691 } VkCopyImageInfo232;
 692 typedef VkCopyImageInfo232 VkCopyImageInfo2KHR32;
 693
 694 typedef struct VkCopyImageToBufferInfo232
 695 {
 696     VkStructureType sType;
 697     const void *pNext;
 698     VkImage DECLSPEC_ALIGN(8) srcImage;
 699     VkImageLayout srcImageLayout;
 700     VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
 701     uint32_t regionCount;
 702     const VkBufferImageCopy232 *pRegions;
 703 } VkCopyImageToBufferInfo232;
 704 typedef VkCopyImageToBufferInfo232 VkCopyImageToBufferInfo2KHR32;
 705
 706 typedef struct VkCopyMemoryToAccelerationStructureInfoKHR32
 707 {
 708     VkStructureType sType;
 709     const void *pNext;
 710     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src;
 711     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst;
 712     VkCopyAccelerationStructureModeKHR mode;
 713 } VkCopyMemoryToAccelerationStructureInfoKHR32;
 714
 715 typedef struct VkCopyMemoryToMicromapInfoEXT32
 716 {
 717     VkStructureType sType;
 718     const void *pNext;
 719     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src;
 720     VkMicromapEXT DECLSPEC_ALIGN(8) dst;
 721     VkCopyMicromapModeEXT mode;
 722 } VkCopyMemoryToMicromapInfoEXT32;
 723
 724 typedef struct VkCopyMicromapInfoEXT32
 725 {
 726     VkStructureType sType;
 727     const void *pNext;
 728     VkMicromapEXT DECLSPEC_ALIGN(8) src;
 729     VkMicromapEXT DECLSPEC_ALIGN(8) dst;
 730     VkCopyMicromapModeEXT mode;
 731 } VkCopyMicromapInfoEXT32;
 732
 733 typedef struct VkCopyMicromapToMemoryInfoEXT32
 734 {
 735     VkStructureType sType;
 736     const void *pNext;
 737     VkMicromapEXT DECLSPEC_ALIGN(8) src;
 738     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst;
 739     VkCopyMicromapModeEXT mode;
 740 } VkCopyMicromapToMemoryInfoEXT32;
 741
 742 typedef struct VkCuLaunchInfoNVX32
 743 {
 744     VkStructureType sType;
 745     const void *pNext;
 746     VkCuFunctionNVX DECLSPEC_ALIGN(8) function;
 747     uint32_t gridDimX;
 748     uint32_t gridDimY;
 749     uint32_t gridDimZ;
 750     uint32_t blockDimX;
 751     uint32_t blockDimY;
 752     uint32_t blockDimZ;
 753     uint32_t sharedMemBytes;
 754     size_t paramCount;
 755     const void * const *pParams;
 756     size_t extraCount;
 757     const void * const *pExtras;
 758 } VkCuLaunchInfoNVX32;
 759
 760 typedef struct VkDebugMarkerMarkerInfoEXT32
 761 {
 762     VkStructureType sType;
 763     const void *pNext;
 764     const char *pMarkerName;
 765     float color[4];
 766 } VkDebugMarkerMarkerInfoEXT32;
 767
 768 typedef struct VkDecompressMemoryRegionNV32
 769 {
 770     VkDeviceAddress DECLSPEC_ALIGN(8) srcAddress;
 771     VkDeviceAddress DECLSPEC_ALIGN(8) dstAddress;
 772     VkDeviceSize DECLSPEC_ALIGN(8) compressedSize;
 773     VkDeviceSize DECLSPEC_ALIGN(8) decompressedSize;
 774     VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethod;
 775 } VkDecompressMemoryRegionNV32;
 776
 777 typedef struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM32
 778 {
 779     VkStructureType sType;
 780     const void *pNext;
 781     uint32_t fragmentDensityOffsetCount;
 782     const VkOffset2D *pFragmentDensityOffsets;
 783 } VkSubpassFragmentDensityMapOffsetEndInfoQCOM32;
 784
 785 typedef struct VkSubpassEndInfo32
 786 {
 787     VkStructureType sType;
 788     const void *pNext;
 789 } VkSubpassEndInfo32;
 790 typedef VkSubpassEndInfo32 VkSubpassEndInfoKHR32;
 791
 792 typedef struct VkIndirectCommandsStreamNV32
 793 {
 794     VkBuffer DECLSPEC_ALIGN(8) buffer;
 795     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 796 } VkIndirectCommandsStreamNV32;
 797
 798 typedef struct VkGeneratedCommandsInfoNV32
 799 {
 800     VkStructureType sType;
 801     const void *pNext;
 802     VkPipelineBindPoint pipelineBindPoint;
 803     VkPipeline DECLSPEC_ALIGN(8) pipeline;
 804     VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
 805     uint32_t streamCount;
 806     const VkIndirectCommandsStreamNV32 *pStreams;
 807     uint32_t sequencesCount;
 808     VkBuffer DECLSPEC_ALIGN(8) preprocessBuffer;
 809     VkDeviceSize DECLSPEC_ALIGN(8) preprocessOffset;
 810     VkDeviceSize DECLSPEC_ALIGN(8) preprocessSize;
 811     VkBuffer DECLSPEC_ALIGN(8) sequencesCountBuffer;
 812     VkDeviceSize DECLSPEC_ALIGN(8) sequencesCountOffset;
 813     VkBuffer DECLSPEC_ALIGN(8) sequencesIndexBuffer;
 814     VkDeviceSize DECLSPEC_ALIGN(8) sequencesIndexOffset;
 815 } VkGeneratedCommandsInfoNV32;
 816
 817 typedef struct VkOpticalFlowExecuteInfoNV32
 818 {
 819     VkStructureType sType;
 820     void *pNext;
 821     VkOpticalFlowExecuteFlagsNV flags;
 822     uint32_t regionCount;
 823     const VkRect2D *pRegions;
 824 } VkOpticalFlowExecuteInfoNV32;
 825
 826 typedef struct VkMemoryBarrier32
 827 {
 828     VkStructureType sType;
 829     const void *pNext;
 830     VkAccessFlags srcAccessMask;
 831     VkAccessFlags dstAccessMask;
 832 } VkMemoryBarrier32;
 833
 834 typedef struct VkBufferMemoryBarrier32
 835 {
 836     VkStructureType sType;
 837     const void *pNext;
 838     VkAccessFlags srcAccessMask;
 839     VkAccessFlags dstAccessMask;
 840     uint32_t srcQueueFamilyIndex;
 841     uint32_t dstQueueFamilyIndex;
 842     VkBuffer DECLSPEC_ALIGN(8) buffer;
 843     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 844     VkDeviceSize DECLSPEC_ALIGN(8) size;
 845 } VkBufferMemoryBarrier32;
 846
 847 typedef struct VkImageMemoryBarrier32
 848 {
 849     VkStructureType sType;
 850     const void *pNext;
 851     VkAccessFlags srcAccessMask;
 852     VkAccessFlags dstAccessMask;
 853     VkImageLayout oldLayout;
 854     VkImageLayout newLayout;
 855     uint32_t srcQueueFamilyIndex;
 856     uint32_t dstQueueFamilyIndex;
 857     VkImage DECLSPEC_ALIGN(8) image;
 858     VkImageSubresourceRange subresourceRange;
 859 } VkImageMemoryBarrier32;
 860
 861 typedef struct VkMemoryBarrier232
 862 {
 863     VkStructureType sType;
 864     const void *pNext;
 865     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
 866     VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
 867     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
 868     VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
 869 } VkMemoryBarrier232;
 870 typedef VkMemoryBarrier232 VkMemoryBarrier2KHR32;
 871
 872 typedef struct VkBufferMemoryBarrier232
 873 {
 874     VkStructureType sType;
 875     const void *pNext;
 876     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
 877     VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
 878     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
 879     VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
 880     uint32_t srcQueueFamilyIndex;
 881     uint32_t dstQueueFamilyIndex;
 882     VkBuffer DECLSPEC_ALIGN(8) buffer;
 883     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 884     VkDeviceSize DECLSPEC_ALIGN(8) size;
 885 } VkBufferMemoryBarrier232;
 886 typedef VkBufferMemoryBarrier232 VkBufferMemoryBarrier2KHR32;
 887
 888 typedef struct VkImageMemoryBarrier232
 889 {
 890     VkStructureType sType;
 891     const void *pNext;
 892     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
 893     VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
 894     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
 895     VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
 896     VkImageLayout oldLayout;
 897     VkImageLayout newLayout;
 898     uint32_t srcQueueFamilyIndex;
 899     uint32_t dstQueueFamilyIndex;
 900     VkImage DECLSPEC_ALIGN(8) image;
 901     VkImageSubresourceRange subresourceRange;
 902 } VkImageMemoryBarrier232;
 903 typedef VkImageMemoryBarrier232 VkImageMemoryBarrier2KHR32;
 904
 905 typedef struct VkDependencyInfo32
 906 {
 907     VkStructureType sType;
 908     const void *pNext;
 909     VkDependencyFlags dependencyFlags;
 910     uint32_t memoryBarrierCount;
 911     const VkMemoryBarrier232 *pMemoryBarriers;
 912     uint32_t bufferMemoryBarrierCount;
 913     const VkBufferMemoryBarrier232 *pBufferMemoryBarriers;
 914     uint32_t imageMemoryBarrierCount;
 915     const VkImageMemoryBarrier232 *pImageMemoryBarriers;
 916 } VkDependencyInfo32;
 917 typedef VkDependencyInfo32 VkDependencyInfoKHR32;
 918
 919 typedef struct VkDescriptorImageInfo32
 920 {
 921     VkSampler DECLSPEC_ALIGN(8) sampler;
 922     VkImageView DECLSPEC_ALIGN(8) imageView;
 923     VkImageLayout imageLayout;
 924 } VkDescriptorImageInfo32;
 925
 926 typedef struct VkDescriptorBufferInfo32
 927 {
 928     VkBuffer DECLSPEC_ALIGN(8) buffer;
 929     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 930     VkDeviceSize DECLSPEC_ALIGN(8) range;
 931 } VkDescriptorBufferInfo32;
 932
 933 typedef struct VkWriteDescriptorSetInlineUniformBlock32
 934 {
 935     VkStructureType sType;
 936     const void *pNext;
 937     uint32_t dataSize;
 938     const void *pData;
 939 } VkWriteDescriptorSetInlineUniformBlock32;
 940 typedef VkWriteDescriptorSetInlineUniformBlock32 VkWriteDescriptorSetInlineUniformBlockEXT32;
 941
 942 typedef struct VkWriteDescriptorSetAccelerationStructureKHR32
 943 {
 944     VkStructureType sType;
 945     const void *pNext;
 946     uint32_t accelerationStructureCount;
 947     const VkAccelerationStructureKHR *pAccelerationStructures;
 948 } VkWriteDescriptorSetAccelerationStructureKHR32;
 949
 950 typedef struct VkWriteDescriptorSetAccelerationStructureNV32
 951 {
 952     VkStructureType sType;
 953     const void *pNext;
 954     uint32_t accelerationStructureCount;
 955     const VkAccelerationStructureNV *pAccelerationStructures;
 956 } VkWriteDescriptorSetAccelerationStructureNV32;
 957
 958 typedef struct VkWriteDescriptorSet32
 959 {
 960     VkStructureType sType;
 961     const void *pNext;
 962     VkDescriptorSet DECLSPEC_ALIGN(8) dstSet;
 963     uint32_t dstBinding;
 964     uint32_t dstArrayElement;
 965     uint32_t descriptorCount;
 966     VkDescriptorType descriptorType;
 967     const VkDescriptorImageInfo32 *pImageInfo;
 968     const VkDescriptorBufferInfo32 *pBufferInfo;
 969     const VkBufferView *pTexelBufferView;
 970 } VkWriteDescriptorSet32;
 971
 972 typedef struct VkImageResolve232
 973 {
 974     VkStructureType sType;
 975     const void *pNext;
 976     VkImageSubresourceLayers srcSubresource;
 977     VkOffset3D srcOffset;
 978     VkImageSubresourceLayers dstSubresource;
 979     VkOffset3D dstOffset;
 980     VkExtent3D extent;
 981 } VkImageResolve232;
 982 typedef VkImageResolve232 VkImageResolve2KHR32;
 983
 984 typedef struct VkResolveImageInfo232
 985 {
 986     VkStructureType sType;
 987     const void *pNext;
 988     VkImage DECLSPEC_ALIGN(8) srcImage;
 989     VkImageLayout srcImageLayout;
 990     VkImage DECLSPEC_ALIGN(8) dstImage;
 991     VkImageLayout dstImageLayout;
 992     uint32_t regionCount;
 993     const VkImageResolve232 *pRegions;
 994 } VkResolveImageInfo232;
 995 typedef VkResolveImageInfo232 VkResolveImageInfo2KHR32;
 996
 997 typedef struct VkPerformanceMarkerInfoINTEL32
 998 {
 999     VkStructureType sType;
1000     const void *pNext;
1001     uint64_t DECLSPEC_ALIGN(8) marker;
1002 } VkPerformanceMarkerInfoINTEL32;
1003
1004 typedef struct VkPerformanceOverrideInfoINTEL32
1005 {
1006     VkStructureType sType;
1007     const void *pNext;
1008     VkPerformanceOverrideTypeINTEL type;
1009     VkBool32 enable;
1010     uint64_t DECLSPEC_ALIGN(8) parameter;
1011 } VkPerformanceOverrideInfoINTEL32;
1012
1013 typedef struct VkPerformanceStreamMarkerInfoINTEL32
1014 {
1015     VkStructureType sType;
1016     const void *pNext;
1017     uint32_t marker;
1018 } VkPerformanceStreamMarkerInfoINTEL32;
1019
1020 typedef struct VkVertexInputBindingDescription2EXT32
1021 {
1022     VkStructureType sType;
1023     void *pNext;
1024     uint32_t binding;
1025     uint32_t stride;
1026     VkVertexInputRate inputRate;
1027     uint32_t divisor;
1028 } VkVertexInputBindingDescription2EXT32;
1029
1030 typedef struct VkVertexInputAttributeDescription2EXT32
1031 {
1032     VkStructureType sType;
1033     void *pNext;
1034     uint32_t location;
1035     uint32_t binding;
1036     VkFormat format;
1037     uint32_t offset;
1038 } VkVertexInputAttributeDescription2EXT32;
1039
1040 typedef struct VkStridedDeviceAddressRegionKHR32
1041 {
1042     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
1043     VkDeviceSize DECLSPEC_ALIGN(8) stride;
1044     VkDeviceSize DECLSPEC_ALIGN(8) size;
1045 } VkStridedDeviceAddressRegionKHR32;
1046
1047 typedef struct VkAccelerationStructureMotionInfoNV32
1048 {
1049     VkStructureType sType;
1050     const void *pNext;
1051     uint32_t maxInstances;
1052     VkAccelerationStructureMotionInfoFlagsNV flags;
1053 } VkAccelerationStructureMotionInfoNV32;
1054
1055 typedef struct VkAccelerationStructureCreateInfoKHR32
1056 {
1057     VkStructureType sType;
1058     const void *pNext;
1059     VkAccelerationStructureCreateFlagsKHR createFlags;
1060     VkBuffer DECLSPEC_ALIGN(8) buffer;
1061     VkDeviceSize DECLSPEC_ALIGN(8) offset;
1062     VkDeviceSize DECLSPEC_ALIGN(8) size;
1063     VkAccelerationStructureTypeKHR type;
1064     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
1065 } VkAccelerationStructureCreateInfoKHR32;
1066
1067 typedef struct VkAccelerationStructureCreateInfoNV32
1068 {
1069     VkStructureType sType;
1070     const void *pNext;
1071     VkDeviceSize DECLSPEC_ALIGN(8) compactedSize;
1072     VkAccelerationStructureInfoNV32 info;
1073 } VkAccelerationStructureCreateInfoNV32;
1074
1075 typedef struct VkDedicatedAllocationBufferCreateInfoNV32
1076 {
1077     VkStructureType sType;
1078     const void *pNext;
1079     VkBool32 dedicatedAllocation;
1080 } VkDedicatedAllocationBufferCreateInfoNV32;
1081
1082 typedef struct VkExternalMemoryBufferCreateInfo32
1083 {
1084     VkStructureType sType;
1085     const void *pNext;
1086     VkExternalMemoryHandleTypeFlags handleTypes;
1087 } VkExternalMemoryBufferCreateInfo32;
1088 typedef VkExternalMemoryBufferCreateInfo32 VkExternalMemoryBufferCreateInfoKHR32;
1089
1090 typedef struct VkBufferOpaqueCaptureAddressCreateInfo32
1091 {
1092     VkStructureType sType;
1093     const void *pNext;
1094     uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress;
1095 } VkBufferOpaqueCaptureAddressCreateInfo32;
1096 typedef VkBufferOpaqueCaptureAddressCreateInfo32 VkBufferOpaqueCaptureAddressCreateInfoKHR32;
1097
1098 typedef struct VkBufferDeviceAddressCreateInfoEXT32
1099 {
1100     VkStructureType sType;
1101     const void *pNext;
1102     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
1103 } VkBufferDeviceAddressCreateInfoEXT32;
1104
1105 typedef struct VkBufferCreateInfo32
1106 {
1107     VkStructureType sType;
1108     const void *pNext;
1109     VkBufferCreateFlags flags;
1110     VkDeviceSize DECLSPEC_ALIGN(8) size;
1111     VkBufferUsageFlags usage;
1112     VkSharingMode sharingMode;
1113     uint32_t queueFamilyIndexCount;
1114     const uint32_t *pQueueFamilyIndices;
1115 } VkBufferCreateInfo32;
1116
1117 typedef struct VkBufferViewCreateInfo32
1118 {
1119     VkStructureType sType;
1120     const void *pNext;
1121     VkBufferViewCreateFlags flags;
1122     VkBuffer DECLSPEC_ALIGN(8) buffer;
1123     VkFormat format;
1124     VkDeviceSize DECLSPEC_ALIGN(8) offset;
1125     VkDeviceSize DECLSPEC_ALIGN(8) range;
1126 } VkBufferViewCreateInfo32;
1127
1128 typedef struct VkCommandPoolCreateInfo32
1129 {
1130     VkStructureType sType;
1131     const void *pNext;
1132     VkCommandPoolCreateFlags flags;
1133     uint32_t queueFamilyIndex;
1134 } VkCommandPoolCreateInfo32;
1135
1136 typedef struct VkPipelineCreationFeedback32
1137 {
1138     VkPipelineCreationFeedbackFlags flags;
1139     uint64_t DECLSPEC_ALIGN(8) duration;
1140 } VkPipelineCreationFeedback32;
1141 typedef VkPipelineCreationFeedback32 VkPipelineCreationFeedbackEXT32;
1142
1143 typedef struct VkShaderModuleCreateInfo32
1144 {
1145     VkStructureType sType;
1146     const void *pNext;
1147     VkShaderModuleCreateFlags flags;
1148     size_t codeSize;
1149     const uint32_t *pCode;
1150 } VkShaderModuleCreateInfo32;
1151
1152 typedef struct VkShaderModuleValidationCacheCreateInfoEXT32
1153 {
1154     VkStructureType sType;
1155     const void *pNext;
1156     VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
1157 } VkShaderModuleValidationCacheCreateInfoEXT32;
1158
1159 typedef struct VkDebugUtilsObjectNameInfoEXT32
1160 {
1161     VkStructureType sType;
1162     const void *pNext;
1163     VkObjectType objectType;
1164     uint64_t DECLSPEC_ALIGN(8) objectHandle;
1165     const char *pObjectName;
1166 } VkDebugUtilsObjectNameInfoEXT32;
1167
1168 typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32
1169 {
1170     VkStructureType sType;
1171     void *pNext;
1172     uint32_t requiredSubgroupSize;
1173 } VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32;
1174 typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT32;
1175
1176 typedef struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT32
1177 {
1178     VkStructureType sType;
1179     const void *pNext;
1180     uint32_t identifierSize;
1181     const uint8_t *pIdentifier;
1182 } VkPipelineShaderStageModuleIdentifierCreateInfoEXT32;
1183
1184 typedef struct VkPipelineRobustnessCreateInfoEXT32
1185 {
1186     VkStructureType sType;
1187     const void *pNext;
1188     VkPipelineRobustnessBufferBehaviorEXT storageBuffers;
1189     VkPipelineRobustnessBufferBehaviorEXT uniformBuffers;
1190     VkPipelineRobustnessBufferBehaviorEXT vertexInputs;
1191     VkPipelineRobustnessImageBehaviorEXT images;
1192 } VkPipelineRobustnessCreateInfoEXT32;
1193
1194 typedef struct VkPipelineShaderStageCreateInfo32
1195 {
1196     VkStructureType sType;
1197     const void *pNext;
1198     VkPipelineShaderStageCreateFlags flags;
1199     VkShaderStageFlagBits stage;
1200     VkShaderModule DECLSPEC_ALIGN(8) module;
1201     const char *pName;
1202     const VkSpecializationInfo *pSpecializationInfo;
1203 } VkPipelineShaderStageCreateInfo32;
1204
1205 typedef struct VkPipelineCreationFeedbackCreateInfo32
1206 {
1207     VkStructureType sType;
1208     const void *pNext;
1209     VkPipelineCreationFeedback32 *pPipelineCreationFeedback;
1210     uint32_t pipelineStageCreationFeedbackCount;
1211     VkPipelineCreationFeedback32 *pPipelineStageCreationFeedbacks;
1212 } VkPipelineCreationFeedbackCreateInfo32;
1213 typedef VkPipelineCreationFeedbackCreateInfo32 VkPipelineCreationFeedbackCreateInfoEXT32;
1214
1215 typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI32
1216 {
1217     VkStructureType sType;
1218     void *pNext;
1219     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
1220     uint32_t subpass;
1221 } VkSubpassShadingPipelineCreateInfoHUAWEI32;
1222
1223 typedef struct VkPipelineCompilerControlCreateInfoAMD32
1224 {
1225     VkStructureType sType;
1226     const void *pNext;
1227     VkPipelineCompilerControlFlagsAMD compilerControlFlags;
1228 } VkPipelineCompilerControlCreateInfoAMD32;
1229
1230 typedef struct VkComputePipelineCreateInfo32
1231 {
1232     VkStructureType sType;
1233     const void *pNext;
1234     VkPipelineCreateFlags flags;
1235     VkPipelineShaderStageCreateInfo32 DECLSPEC_ALIGN(8) stage;
1236     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
1237     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
1238     int32_t basePipelineIndex;
1239 } VkComputePipelineCreateInfo32;
1240
1241 typedef struct VkCuFunctionCreateInfoNVX32
1242 {
1243     VkStructureType sType;
1244     const void *pNext;
1245     VkCuModuleNVX DECLSPEC_ALIGN(8) module;
1246     const char *pName;
1247 } VkCuFunctionCreateInfoNVX32;
1248
1249 typedef struct VkCuModuleCreateInfoNVX32
1250 {
1251     VkStructureType sType;
1252     const void *pNext;
1253     size_t dataSize;
1254     const void *pData;
1255 } VkCuModuleCreateInfoNVX32;
1256
1257 typedef struct VkDebugReportCallbackCreateInfoEXT32
1258 {
1259     VkStructureType sType;
1260     const void *pNext;
1261     VkDebugReportFlagsEXT flags;
1262     PFN_vkDebugReportCallbackEXT pfnCallback;
1263     void *pUserData;
1264 } VkDebugReportCallbackCreateInfoEXT32;
1265
1266 typedef struct VkDebugUtilsMessengerCreateInfoEXT32
1267 {
1268     VkStructureType sType;
1269     const void *pNext;
1270     VkDebugUtilsMessengerCreateFlagsEXT flags;
1271     VkDebugUtilsMessageSeverityFlagsEXT messageSeverity;
1272     VkDebugUtilsMessageTypeFlagsEXT messageType;
1273     PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback;
1274     void *pUserData;
1275 } VkDebugUtilsMessengerCreateInfoEXT32;
1276
1277 typedef struct VkDescriptorPoolInlineUniformBlockCreateInfo32
1278 {
1279     VkStructureType sType;
1280     const void *pNext;
1281     uint32_t maxInlineUniformBlockBindings;
1282 } VkDescriptorPoolInlineUniformBlockCreateInfo32;
1283 typedef VkDescriptorPoolInlineUniformBlockCreateInfo32 VkDescriptorPoolInlineUniformBlockCreateInfoEXT32;
1284
1285 typedef struct VkMutableDescriptorTypeCreateInfoEXT32
1286 {
1287     VkStructureType sType;
1288     const void *pNext;
1289     uint32_t mutableDescriptorTypeListCount;
1290     const VkMutableDescriptorTypeListEXT *pMutableDescriptorTypeLists;
1291 } VkMutableDescriptorTypeCreateInfoEXT32;
1292 typedef VkMutableDescriptorTypeCreateInfoEXT32 VkMutableDescriptorTypeCreateInfoVALVE32;
1293
1294 typedef struct VkDescriptorPoolCreateInfo32
1295 {
1296     VkStructureType sType;
1297     const void *pNext;
1298     VkDescriptorPoolCreateFlags flags;
1299     uint32_t maxSets;
1300     uint32_t poolSizeCount;
1301     const VkDescriptorPoolSize *pPoolSizes;
1302 } VkDescriptorPoolCreateInfo32;
1303
1304 typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo32
1305 {
1306     VkStructureType sType;
1307     const void *pNext;
1308     uint32_t bindingCount;
1309     const VkDescriptorBindingFlags *pBindingFlags;
1310 } VkDescriptorSetLayoutBindingFlagsCreateInfo32;
1311 typedef VkDescriptorSetLayoutBindingFlagsCreateInfo32 VkDescriptorSetLayoutBindingFlagsCreateInfoEXT32;
1312
1313 typedef struct VkDescriptorSetLayoutCreateInfo32
1314 {
1315     VkStructureType sType;
1316     const void *pNext;
1317     VkDescriptorSetLayoutCreateFlags flags;
1318     uint32_t bindingCount;
1319     const VkDescriptorSetLayoutBinding *pBindings;
1320 } VkDescriptorSetLayoutCreateInfo32;
1321
1322 typedef struct VkDescriptorUpdateTemplateCreateInfo32
1323 {
1324     VkStructureType sType;
1325     const void *pNext;
1326     VkDescriptorUpdateTemplateCreateFlags flags;
1327     uint32_t descriptorUpdateEntryCount;
1328     const VkDescriptorUpdateTemplateEntry *pDescriptorUpdateEntries;
1329     VkDescriptorUpdateTemplateType templateType;
1330     VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
1331     VkPipelineBindPoint pipelineBindPoint;
1332     VkPipelineLayout DECLSPEC_ALIGN(8) pipelineLayout;
1333     uint32_t set;
1334 } VkDescriptorUpdateTemplateCreateInfo32;
1335 typedef VkDescriptorUpdateTemplateCreateInfo32 VkDescriptorUpdateTemplateCreateInfoKHR32;
1336
1337 typedef struct VkDeviceQueueGlobalPriorityCreateInfoKHR32
1338 {
1339     VkStructureType sType;
1340     const void *pNext;
1341     VkQueueGlobalPriorityKHR globalPriority;
1342 } VkDeviceQueueGlobalPriorityCreateInfoKHR32;
1343 typedef VkDeviceQueueGlobalPriorityCreateInfoKHR32 VkDeviceQueueGlobalPriorityCreateInfoEXT32;
1344
1345 typedef struct VkDeviceQueueCreateInfo32
1346 {
1347     VkStructureType sType;
1348     const void *pNext;
1349     VkDeviceQueueCreateFlags flags;
1350     uint32_t queueFamilyIndex;
1351     uint32_t queueCount;
1352     const float *pQueuePriorities;
1353 } VkDeviceQueueCreateInfo32;
1354
1355 typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32
1356 {
1357     VkStructureType sType;
1358     void *pNext;
1359     VkBool32 deviceGeneratedCommands;
1360 } VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32;
1361
1362 typedef struct VkDevicePrivateDataCreateInfo32
1363 {
1364     VkStructureType sType;
1365     const void *pNext;
1366     uint32_t privateDataSlotRequestCount;
1367 } VkDevicePrivateDataCreateInfo32;
1368 typedef VkDevicePrivateDataCreateInfo32 VkDevicePrivateDataCreateInfoEXT32;
1369
1370 typedef struct VkPhysicalDevicePrivateDataFeatures32
1371 {
1372     VkStructureType sType;
1373     void *pNext;
1374     VkBool32 privateData;
1375 } VkPhysicalDevicePrivateDataFeatures32;
1376 typedef VkPhysicalDevicePrivateDataFeatures32 VkPhysicalDevicePrivateDataFeaturesEXT32;
1377
1378 typedef struct VkPhysicalDeviceFeatures232
1379 {
1380     VkStructureType sType;
1381     void *pNext;
1382     VkPhysicalDeviceFeatures features;
1383 } VkPhysicalDeviceFeatures232;
1384 typedef VkPhysicalDeviceFeatures232 VkPhysicalDeviceFeatures2KHR32;
1385
1386 typedef struct VkPhysicalDeviceVariablePointersFeatures32
1387 {
1388     VkStructureType sType;
1389     void *pNext;
1390     VkBool32 variablePointersStorageBuffer;
1391     VkBool32 variablePointers;
1392 } VkPhysicalDeviceVariablePointersFeatures32;
1393 typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointersFeaturesKHR32;
1394 typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointerFeaturesKHR32;
1395 typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointerFeatures32;
1396
1397 typedef struct VkPhysicalDeviceMultiviewFeatures32
1398 {
1399     VkStructureType sType;
1400     void *pNext;
1401     VkBool32 multiview;
1402     VkBool32 multiviewGeometryShader;
1403     VkBool32 multiviewTessellationShader;
1404 } VkPhysicalDeviceMultiviewFeatures32;
1405 typedef VkPhysicalDeviceMultiviewFeatures32 VkPhysicalDeviceMultiviewFeaturesKHR32;
1406
1407 typedef struct VkDeviceGroupDeviceCreateInfo32
1408 {
1409     VkStructureType sType;
1410     const void *pNext;
1411     uint32_t physicalDeviceCount;
1412     const VkPhysicalDevice *pPhysicalDevices;
1413 } VkDeviceGroupDeviceCreateInfo32;
1414 typedef VkDeviceGroupDeviceCreateInfo32 VkDeviceGroupDeviceCreateInfoKHR32;
1415
1416 typedef struct VkPhysicalDevicePresentIdFeaturesKHR32
1417 {
1418     VkStructureType sType;
1419     void *pNext;
1420     VkBool32 presentId;
1421 } VkPhysicalDevicePresentIdFeaturesKHR32;
1422
1423 typedef struct VkPhysicalDevicePresentWaitFeaturesKHR32
1424 {
1425     VkStructureType sType;
1426     void *pNext;
1427     VkBool32 presentWait;
1428 } VkPhysicalDevicePresentWaitFeaturesKHR32;
1429
1430 typedef struct VkPhysicalDevice16BitStorageFeatures32
1431 {
1432     VkStructureType sType;
1433     void *pNext;
1434     VkBool32 storageBuffer16BitAccess;
1435     VkBool32 uniformAndStorageBuffer16BitAccess;
1436     VkBool32 storagePushConstant16;
1437     VkBool32 storageInputOutput16;
1438 } VkPhysicalDevice16BitStorageFeatures32;
1439 typedef VkPhysicalDevice16BitStorageFeatures32 VkPhysicalDevice16BitStorageFeaturesKHR32;
1440
1441 typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32
1442 {
1443     VkStructureType sType;
1444     void *pNext;
1445     VkBool32 shaderSubgroupExtendedTypes;
1446 } VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32;
1447 typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR32;
1448
1449 typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures32
1450 {
1451     VkStructureType sType;
1452     void *pNext;
1453     VkBool32 samplerYcbcrConversion;
1454 } VkPhysicalDeviceSamplerYcbcrConversionFeatures32;
1455 typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures32 VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR32;
1456
1457 typedef struct VkPhysicalDeviceProtectedMemoryFeatures32
1458 {
1459     VkStructureType sType;
1460     void *pNext;
1461     VkBool32 protectedMemory;
1462 } VkPhysicalDeviceProtectedMemoryFeatures32;
1463
1464 typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32
1465 {
1466     VkStructureType sType;
1467     void *pNext;
1468     VkBool32 advancedBlendCoherentOperations;
1469 } VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32;
1470
1471 typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT32
1472 {
1473     VkStructureType sType;
1474     void *pNext;
1475     VkBool32 multiDraw;
1476 } VkPhysicalDeviceMultiDrawFeaturesEXT32;
1477
1478 typedef struct VkPhysicalDeviceInlineUniformBlockFeatures32
1479 {
1480     VkStructureType sType;
1481     void *pNext;
1482     VkBool32 inlineUniformBlock;
1483     VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
1484 } VkPhysicalDeviceInlineUniformBlockFeatures32;
1485 typedef VkPhysicalDeviceInlineUniformBlockFeatures32 VkPhysicalDeviceInlineUniformBlockFeaturesEXT32;
1486
1487 typedef struct VkPhysicalDeviceMaintenance4Features32
1488 {
1489     VkStructureType sType;
1490     void *pNext;
1491     VkBool32 maintenance4;
1492 } VkPhysicalDeviceMaintenance4Features32;
1493 typedef VkPhysicalDeviceMaintenance4Features32 VkPhysicalDeviceMaintenance4FeaturesKHR32;
1494
1495 typedef struct VkPhysicalDeviceShaderDrawParametersFeatures32
1496 {
1497     VkStructureType sType;
1498     void *pNext;
1499     VkBool32 shaderDrawParameters;
1500 } VkPhysicalDeviceShaderDrawParametersFeatures32;
1501 typedef VkPhysicalDeviceShaderDrawParametersFeatures32 VkPhysicalDeviceShaderDrawParameterFeatures32;
1502
1503 typedef struct VkPhysicalDeviceShaderFloat16Int8Features32
1504 {
1505     VkStructureType sType;
1506     void *pNext;
1507     VkBool32 shaderFloat16;
1508     VkBool32 shaderInt8;
1509 } VkPhysicalDeviceShaderFloat16Int8Features32;
1510 typedef VkPhysicalDeviceShaderFloat16Int8Features32 VkPhysicalDeviceShaderFloat16Int8FeaturesKHR32;
1511 typedef VkPhysicalDeviceShaderFloat16Int8Features32 VkPhysicalDeviceFloat16Int8FeaturesKHR32;
1512
1513 typedef struct VkPhysicalDeviceHostQueryResetFeatures32
1514 {
1515     VkStructureType sType;
1516     void *pNext;
1517     VkBool32 hostQueryReset;
1518 } VkPhysicalDeviceHostQueryResetFeatures32;
1519 typedef VkPhysicalDeviceHostQueryResetFeatures32 VkPhysicalDeviceHostQueryResetFeaturesEXT32;
1520
1521 typedef struct VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32
1522 {
1523     VkStructureType sType;
1524     void *pNext;
1525     VkBool32 globalPriorityQuery;
1526 } VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32;
1527 typedef VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT32;
1528
1529 typedef struct VkPhysicalDeviceDescriptorIndexingFeatures32
1530 {
1531     VkStructureType sType;
1532     void *pNext;
1533     VkBool32 shaderInputAttachmentArrayDynamicIndexing;
1534     VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;
1535     VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;
1536     VkBool32 shaderUniformBufferArrayNonUniformIndexing;
1537     VkBool32 shaderSampledImageArrayNonUniformIndexing;
1538     VkBool32 shaderStorageBufferArrayNonUniformIndexing;
1539     VkBool32 shaderStorageImageArrayNonUniformIndexing;
1540     VkBool32 shaderInputAttachmentArrayNonUniformIndexing;
1541     VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;
1542     VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;
1543     VkBool32 descriptorBindingUniformBufferUpdateAfterBind;
1544     VkBool32 descriptorBindingSampledImageUpdateAfterBind;
1545     VkBool32 descriptorBindingStorageImageUpdateAfterBind;
1546     VkBool32 descriptorBindingStorageBufferUpdateAfterBind;
1547     VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
1548     VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
1549     VkBool32 descriptorBindingUpdateUnusedWhilePending;
1550     VkBool32 descriptorBindingPartiallyBound;
1551     VkBool32 descriptorBindingVariableDescriptorCount;
1552     VkBool32 runtimeDescriptorArray;
1553 } VkPhysicalDeviceDescriptorIndexingFeatures32;
1554 typedef VkPhysicalDeviceDescriptorIndexingFeatures32 VkPhysicalDeviceDescriptorIndexingFeaturesEXT32;
1555
1556 typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures32
1557 {
1558     VkStructureType sType;
1559     void *pNext;
1560     VkBool32 timelineSemaphore;
1561 } VkPhysicalDeviceTimelineSemaphoreFeatures32;
1562 typedef VkPhysicalDeviceTimelineSemaphoreFeatures32 VkPhysicalDeviceTimelineSemaphoreFeaturesKHR32;
1563
1564 typedef struct VkPhysicalDevice8BitStorageFeatures32
1565 {
1566     VkStructureType sType;
1567     void *pNext;
1568     VkBool32 storageBuffer8BitAccess;
1569     VkBool32 uniformAndStorageBuffer8BitAccess;
1570     VkBool32 storagePushConstant8;
1571 } VkPhysicalDevice8BitStorageFeatures32;
1572 typedef VkPhysicalDevice8BitStorageFeatures32 VkPhysicalDevice8BitStorageFeaturesKHR32;
1573
1574 typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT32
1575 {
1576     VkStructureType sType;
1577     void *pNext;
1578     VkBool32 conditionalRendering;
1579     VkBool32 inheritedConditionalRendering;
1580 } VkPhysicalDeviceConditionalRenderingFeaturesEXT32;
1581
1582 typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures32
1583 {
1584     VkStructureType sType;
1585     void *pNext;
1586     VkBool32 vulkanMemoryModel;
1587     VkBool32 vulkanMemoryModelDeviceScope;
1588     VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
1589 } VkPhysicalDeviceVulkanMemoryModelFeatures32;
1590 typedef VkPhysicalDeviceVulkanMemoryModelFeatures32 VkPhysicalDeviceVulkanMemoryModelFeaturesKHR32;
1591
1592 typedef struct VkPhysicalDeviceShaderAtomicInt64Features32
1593 {
1594     VkStructureType sType;
1595     void *pNext;
1596     VkBool32 shaderBufferInt64Atomics;
1597     VkBool32 shaderSharedInt64Atomics;
1598 } VkPhysicalDeviceShaderAtomicInt64Features32;
1599 typedef VkPhysicalDeviceShaderAtomicInt64Features32 VkPhysicalDeviceShaderAtomicInt64FeaturesKHR32;
1600
1601 typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32
1602 {
1603     VkStructureType sType;
1604     void *pNext;
1605     VkBool32 shaderBufferFloat32Atomics;
1606     VkBool32 shaderBufferFloat32AtomicAdd;
1607     VkBool32 shaderBufferFloat64Atomics;
1608     VkBool32 shaderBufferFloat64AtomicAdd;
1609     VkBool32 shaderSharedFloat32Atomics;
1610     VkBool32 shaderSharedFloat32AtomicAdd;
1611     VkBool32 shaderSharedFloat64Atomics;
1612     VkBool32 shaderSharedFloat64AtomicAdd;
1613     VkBool32 shaderImageFloat32Atomics;
1614     VkBool32 shaderImageFloat32AtomicAdd;
1615     VkBool32 sparseImageFloat32Atomics;
1616     VkBool32 sparseImageFloat32AtomicAdd;
1617 } VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32;
1618
1619 typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32
1620 {
1621     VkStructureType sType;
1622     void *pNext;
1623     VkBool32 shaderBufferFloat16Atomics;
1624     VkBool32 shaderBufferFloat16AtomicAdd;
1625     VkBool32 shaderBufferFloat16AtomicMinMax;
1626     VkBool32 shaderBufferFloat32AtomicMinMax;
1627     VkBool32 shaderBufferFloat64AtomicMinMax;
1628     VkBool32 shaderSharedFloat16Atomics;
1629     VkBool32 shaderSharedFloat16AtomicAdd;
1630     VkBool32 shaderSharedFloat16AtomicMinMax;
1631     VkBool32 shaderSharedFloat32AtomicMinMax;
1632     VkBool32 shaderSharedFloat64AtomicMinMax;
1633     VkBool32 shaderImageFloat32AtomicMinMax;
1634     VkBool32 sparseImageFloat32AtomicMinMax;
1635 } VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32;
1636
1637 typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32
1638 {
1639     VkStructureType sType;
1640     void *pNext;
1641     VkBool32 vertexAttributeInstanceRateDivisor;
1642     VkBool32 vertexAttributeInstanceRateZeroDivisor;
1643 } VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32;
1644
1645 typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT32
1646 {
1647     VkStructureType sType;
1648     void *pNext;
1649     VkBool32 decodeModeSharedExponent;
1650 } VkPhysicalDeviceASTCDecodeFeaturesEXT32;
1651
1652 typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT32
1653 {
1654     VkStructureType sType;
1655     void *pNext;
1656     VkBool32 transformFeedback;
1657     VkBool32 geometryStreams;
1658 } VkPhysicalDeviceTransformFeedbackFeaturesEXT32;
1659
1660 typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32
1661 {
1662     VkStructureType sType;
1663     void *pNext;
1664     VkBool32 representativeFragmentTest;
1665 } VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32;
1666
1667 typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV32
1668 {
1669     VkStructureType sType;
1670     void *pNext;
1671     VkBool32 exclusiveScissor;
1672 } VkPhysicalDeviceExclusiveScissorFeaturesNV32;
1673
1674 typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV32
1675 {
1676     VkStructureType sType;
1677     void *pNext;
1678     VkBool32 cornerSampledImage;
1679 } VkPhysicalDeviceCornerSampledImageFeaturesNV32;
1680
1681 typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32
1682 {
1683     VkStructureType sType;
1684     void *pNext;
1685     VkBool32 computeDerivativeGroupQuads;
1686     VkBool32 computeDerivativeGroupLinear;
1687 } VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32;
1688
1689 typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV32
1690 {
1691     VkStructureType sType;
1692     void *pNext;
1693     VkBool32 imageFootprint;
1694 } VkPhysicalDeviceShaderImageFootprintFeaturesNV32;
1695
1696 typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32
1697 {
1698     VkStructureType sType;
1699     void *pNext;
1700     VkBool32 dedicatedAllocationImageAliasing;
1701 } VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32;
1702
1703 typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32
1704 {
1705     VkStructureType sType;
1706     void *pNext;
1707     VkBool32 indirectCopy;
1708 } VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32;
1709
1710 typedef struct VkPhysicalDeviceMemoryDecompressionFeaturesNV32
1711 {
1712     VkStructureType sType;
1713     void *pNext;
1714     VkBool32 memoryDecompression;
1715 } VkPhysicalDeviceMemoryDecompressionFeaturesNV32;
1716
1717 typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV32
1718 {
1719     VkStructureType sType;
1720     void *pNext;
1721     VkBool32 shadingRateImage;
1722     VkBool32 shadingRateCoarseSampleOrder;
1723 } VkPhysicalDeviceShadingRateImageFeaturesNV32;
1724
1725 typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32
1726 {
1727     VkStructureType sType;
1728     void *pNext;
1729     VkBool32 invocationMask;
1730 } VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32;
1731
1732 typedef struct VkPhysicalDeviceMeshShaderFeaturesNV32
1733 {
1734     VkStructureType sType;
1735     void *pNext;
1736     VkBool32 taskShader;
1737     VkBool32 meshShader;
1738 } VkPhysicalDeviceMeshShaderFeaturesNV32;
1739
1740 typedef struct VkPhysicalDeviceMeshShaderFeaturesEXT32
1741 {
1742     VkStructureType sType;
1743     void *pNext;
1744     VkBool32 taskShader;
1745     VkBool32 meshShader;
1746     VkBool32 multiviewMeshShader;
1747     VkBool32 primitiveFragmentShadingRateMeshShader;
1748     VkBool32 meshShaderQueries;
1749 } VkPhysicalDeviceMeshShaderFeaturesEXT32;
1750
1751 typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR32
1752 {
1753     VkStructureType sType;
1754     void *pNext;
1755     VkBool32 accelerationStructure;
1756     VkBool32 accelerationStructureCaptureReplay;
1757     VkBool32 accelerationStructureIndirectBuild;
1758     VkBool32 accelerationStructureHostCommands;
1759     VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind;
1760 } VkPhysicalDeviceAccelerationStructureFeaturesKHR32;
1761
1762 typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR32
1763 {
1764     VkStructureType sType;
1765     void *pNext;
1766     VkBool32 rayTracingPipeline;
1767     VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay;
1768     VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
1769     VkBool32 rayTracingPipelineTraceRaysIndirect;
1770     VkBool32 rayTraversalPrimitiveCulling;
1771 } VkPhysicalDeviceRayTracingPipelineFeaturesKHR32;
1772
1773 typedef struct VkPhysicalDeviceRayQueryFeaturesKHR32
1774 {
1775     VkStructureType sType;
1776     void *pNext;
1777     VkBool32 rayQuery;
1778 } VkPhysicalDeviceRayQueryFeaturesKHR32;
1779
1780 typedef struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32
1781 {
1782     VkStructureType sType;
1783     void *pNext;
1784     VkBool32 rayTracingMaintenance1;
1785     VkBool32 rayTracingPipelineTraceRaysIndirect2;
1786 } VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32;
1787
1788 typedef struct VkDeviceMemoryOverallocationCreateInfoAMD32
1789 {
1790     VkStructureType sType;
1791     const void *pNext;
1792     VkMemoryOverallocationBehaviorAMD overallocationBehavior;
1793 } VkDeviceMemoryOverallocationCreateInfoAMD32;
1794
1795 typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT32
1796 {
1797     VkStructureType sType;
1798     void *pNext;
1799     VkBool32 fragmentDensityMap;
1800     VkBool32 fragmentDensityMapDynamic;
1801     VkBool32 fragmentDensityMapNonSubsampledImages;
1802 } VkPhysicalDeviceFragmentDensityMapFeaturesEXT32;
1803
1804 typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32
1805 {
1806     VkStructureType sType;
1807     void *pNext;
1808     VkBool32 fragmentDensityMapDeferred;
1809 } VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32;
1810
1811 typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32
1812 {
1813     VkStructureType sType;
1814     void *pNext;
1815     VkBool32 fragmentDensityMapOffset;
1816 } VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32;
1817
1818 typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures32
1819 {
1820     VkStructureType sType;
1821     void *pNext;
1822     VkBool32 scalarBlockLayout;
1823 } VkPhysicalDeviceScalarBlockLayoutFeatures32;
1824 typedef VkPhysicalDeviceScalarBlockLayoutFeatures32 VkPhysicalDeviceScalarBlockLayoutFeaturesEXT32;
1825
1826 typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures32
1827 {
1828     VkStructureType sType;
1829     void *pNext;
1830     VkBool32 uniformBufferStandardLayout;
1831 } VkPhysicalDeviceUniformBufferStandardLayoutFeatures32;
1832 typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR32;
1833
1834 typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT32
1835 {
1836     VkStructureType sType;
1837     void *pNext;
1838     VkBool32 depthClipEnable;
1839 } VkPhysicalDeviceDepthClipEnableFeaturesEXT32;
1840
1841 typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT32
1842 {
1843     VkStructureType sType;
1844     void *pNext;
1845     VkBool32 memoryPriority;
1846 } VkPhysicalDeviceMemoryPriorityFeaturesEXT32;
1847
1848 typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32
1849 {
1850     VkStructureType sType;
1851     void *pNext;
1852     VkBool32 pageableDeviceLocalMemory;
1853 } VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32;
1854
1855 typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures32
1856 {
1857     VkStructureType sType;
1858     void *pNext;
1859     VkBool32 bufferDeviceAddress;
1860     VkBool32 bufferDeviceAddressCaptureReplay;
1861     VkBool32 bufferDeviceAddressMultiDevice;
1862 } VkPhysicalDeviceBufferDeviceAddressFeatures32;
1863 typedef VkPhysicalDeviceBufferDeviceAddressFeatures32 VkPhysicalDeviceBufferDeviceAddressFeaturesKHR32;
1864
1865 typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32
1866 {
1867     VkStructureType sType;
1868     void *pNext;
1869     VkBool32 bufferDeviceAddress;
1870     VkBool32 bufferDeviceAddressCaptureReplay;
1871     VkBool32 bufferDeviceAddressMultiDevice;
1872 } VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32;
1873 typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 VkPhysicalDeviceBufferAddressFeaturesEXT32;
1874
1875 typedef struct VkPhysicalDeviceImagelessFramebufferFeatures32
1876 {
1877     VkStructureType sType;
1878     void *pNext;
1879     VkBool32 imagelessFramebuffer;
1880 } VkPhysicalDeviceImagelessFramebufferFeatures32;
1881 typedef VkPhysicalDeviceImagelessFramebufferFeatures32 VkPhysicalDeviceImagelessFramebufferFeaturesKHR32;
1882
1883 typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures32
1884 {
1885     VkStructureType sType;
1886     void *pNext;
1887     VkBool32 textureCompressionASTC_HDR;
1888 } VkPhysicalDeviceTextureCompressionASTCHDRFeatures32;
1889 typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT32;
1890
1891 typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV32
1892 {
1893     VkStructureType sType;
1894     void *pNext;
1895     VkBool32 cooperativeMatrix;
1896     VkBool32 cooperativeMatrixRobustBufferAccess;
1897 } VkPhysicalDeviceCooperativeMatrixFeaturesNV32;
1898
1899 typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32
1900 {
1901     VkStructureType sType;
1902     void *pNext;
1903     VkBool32 ycbcrImageArrays;
1904 } VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32;
1905
1906 typedef struct VkPhysicalDevicePresentBarrierFeaturesNV32
1907 {
1908     VkStructureType sType;
1909     void *pNext;
1910     VkBool32 presentBarrier;
1911 } VkPhysicalDevicePresentBarrierFeaturesNV32;
1912
1913 typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR32
1914 {
1915     VkStructureType sType;
1916     void *pNext;
1917     VkBool32 performanceCounterQueryPools;
1918     VkBool32 performanceCounterMultipleQueryPools;
1919 } VkPhysicalDevicePerformanceQueryFeaturesKHR32;
1920
1921 typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV32
1922 {
1923     VkStructureType sType;
1924     void *pNext;
1925     VkBool32 coverageReductionMode;
1926 } VkPhysicalDeviceCoverageReductionModeFeaturesNV32;
1927
1928 typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32
1929 {
1930     VkStructureType sType;
1931     void *pNext;
1932     VkBool32 shaderIntegerFunctions2;
1933 } VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32;
1934
1935 typedef struct VkPhysicalDeviceShaderClockFeaturesKHR32
1936 {
1937     VkStructureType sType;
1938     void *pNext;
1939     VkBool32 shaderSubgroupClock;
1940     VkBool32 shaderDeviceClock;
1941 } VkPhysicalDeviceShaderClockFeaturesKHR32;
1942
1943 typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT32
1944 {
1945     VkStructureType sType;
1946     void *pNext;
1947     VkBool32 indexTypeUint8;
1948 } VkPhysicalDeviceIndexTypeUint8FeaturesEXT32;
1949
1950 typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32
1951 {
1952     VkStructureType sType;
1953     void *pNext;
1954     VkBool32 shaderSMBuiltins;
1955 } VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32;
1956
1957 typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32
1958 {
1959     VkStructureType sType;
1960     void *pNext;
1961     VkBool32 fragmentShaderSampleInterlock;
1962     VkBool32 fragmentShaderPixelInterlock;
1963     VkBool32 fragmentShaderShadingRateInterlock;
1964 } VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32;
1965
1966 typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32
1967 {
1968     VkStructureType sType;
1969     void *pNext;
1970     VkBool32 separateDepthStencilLayouts;
1971 } VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32;
1972 typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR32;
1973
1974 typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32
1975 {
1976     VkStructureType sType;
1977     void *pNext;
1978     VkBool32 primitiveTopologyListRestart;
1979     VkBool32 primitiveTopologyPatchListRestart;
1980 } VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32;
1981
1982 typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32
1983 {
1984     VkStructureType sType;
1985     void *pNext;
1986     VkBool32 pipelineExecutableInfo;
1987 } VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32;
1988
1989 typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32
1990 {
1991     VkStructureType sType;
1992     void *pNext;
1993     VkBool32 shaderDemoteToHelperInvocation;
1994 } VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32;
1995 typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT32;
1996
1997 typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32
1998 {
1999     VkStructureType sType;
2000     void *pNext;
2001     VkBool32 texelBufferAlignment;
2002 } VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32;
2003
2004 typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures32
2005 {
2006     VkStructureType sType;
2007     void *pNext;
2008     VkBool32 subgroupSizeControl;
2009     VkBool32 computeFullSubgroups;
2010 } VkPhysicalDeviceSubgroupSizeControlFeatures32;
2011 typedef VkPhysicalDeviceSubgroupSizeControlFeatures32 VkPhysicalDeviceSubgroupSizeControlFeaturesEXT32;
2012
2013 typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT32
2014 {
2015     VkStructureType sType;
2016     void *pNext;
2017     VkBool32 rectangularLines;
2018     VkBool32 bresenhamLines;
2019     VkBool32 smoothLines;
2020     VkBool32 stippledRectangularLines;
2021     VkBool32 stippledBresenhamLines;
2022     VkBool32 stippledSmoothLines;
2023 } VkPhysicalDeviceLineRasterizationFeaturesEXT32;
2024
2025 typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures32
2026 {
2027     VkStructureType sType;
2028     void *pNext;
2029     VkBool32 pipelineCreationCacheControl;
2030 } VkPhysicalDevicePipelineCreationCacheControlFeatures32;
2031 typedef VkPhysicalDevicePipelineCreationCacheControlFeatures32 VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT32;
2032
2033 typedef struct VkPhysicalDeviceVulkan11Features32
2034 {
2035     VkStructureType sType;
2036     void *pNext;
2037     VkBool32 storageBuffer16BitAccess;
2038     VkBool32 uniformAndStorageBuffer16BitAccess;
2039     VkBool32 storagePushConstant16;
2040     VkBool32 storageInputOutput16;
2041     VkBool32 multiview;
2042     VkBool32 multiviewGeometryShader;
2043     VkBool32 multiviewTessellationShader;
2044     VkBool32 variablePointersStorageBuffer;
2045     VkBool32 variablePointers;
2046     VkBool32 protectedMemory;
2047     VkBool32 samplerYcbcrConversion;
2048     VkBool32 shaderDrawParameters;
2049 } VkPhysicalDeviceVulkan11Features32;
2050
2051 typedef struct VkPhysicalDeviceVulkan12Features32
2052 {
2053     VkStructureType sType;
2054     void *pNext;
2055     VkBool32 samplerMirrorClampToEdge;
2056     VkBool32 drawIndirectCount;
2057     VkBool32 storageBuffer8BitAccess;
2058     VkBool32 uniformAndStorageBuffer8BitAccess;
2059     VkBool32 storagePushConstant8;
2060     VkBool32 shaderBufferInt64Atomics;
2061     VkBool32 shaderSharedInt64Atomics;
2062     VkBool32 shaderFloat16;
2063     VkBool32 shaderInt8;
2064     VkBool32 descriptorIndexing;
2065     VkBool32 shaderInputAttachmentArrayDynamicIndexing;
2066     VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;
2067     VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;
2068     VkBool32 shaderUniformBufferArrayNonUniformIndexing;
2069     VkBool32 shaderSampledImageArrayNonUniformIndexing;
2070     VkBool32 shaderStorageBufferArrayNonUniformIndexing;
2071     VkBool32 shaderStorageImageArrayNonUniformIndexing;
2072     VkBool32 shaderInputAttachmentArrayNonUniformIndexing;
2073     VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;
2074     VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;
2075     VkBool32 descriptorBindingUniformBufferUpdateAfterBind;
2076     VkBool32 descriptorBindingSampledImageUpdateAfterBind;
2077     VkBool32 descriptorBindingStorageImageUpdateAfterBind;
2078     VkBool32 descriptorBindingStorageBufferUpdateAfterBind;
2079     VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
2080     VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
2081     VkBool32 descriptorBindingUpdateUnusedWhilePending;
2082     VkBool32 descriptorBindingPartiallyBound;
2083     VkBool32 descriptorBindingVariableDescriptorCount;
2084     VkBool32 runtimeDescriptorArray;
2085     VkBool32 samplerFilterMinmax;
2086     VkBool32 scalarBlockLayout;
2087     VkBool32 imagelessFramebuffer;
2088     VkBool32 uniformBufferStandardLayout;
2089     VkBool32 shaderSubgroupExtendedTypes;
2090     VkBool32 separateDepthStencilLayouts;
2091     VkBool32 hostQueryReset;
2092     VkBool32 timelineSemaphore;
2093     VkBool32 bufferDeviceAddress;
2094     VkBool32 bufferDeviceAddressCaptureReplay;
2095     VkBool32 bufferDeviceAddressMultiDevice;
2096     VkBool32 vulkanMemoryModel;
2097     VkBool32 vulkanMemoryModelDeviceScope;
2098     VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
2099     VkBool32 shaderOutputViewportIndex;
2100     VkBool32 shaderOutputLayer;
2101     VkBool32 subgroupBroadcastDynamicId;
2102 } VkPhysicalDeviceVulkan12Features32;
2103
2104 typedef struct VkPhysicalDeviceVulkan13Features32
2105 {
2106     VkStructureType sType;
2107     void *pNext;
2108     VkBool32 robustImageAccess;
2109     VkBool32 inlineUniformBlock;
2110     VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
2111     VkBool32 pipelineCreationCacheControl;
2112     VkBool32 privateData;
2113     VkBool32 shaderDemoteToHelperInvocation;
2114     VkBool32 shaderTerminateInvocation;
2115     VkBool32 subgroupSizeControl;
2116     VkBool32 computeFullSubgroups;
2117     VkBool32 synchronization2;
2118     VkBool32 textureCompressionASTC_HDR;
2119     VkBool32 shaderZeroInitializeWorkgroupMemory;
2120     VkBool32 dynamicRendering;
2121     VkBool32 shaderIntegerDotProduct;
2122     VkBool32 maintenance4;
2123 } VkPhysicalDeviceVulkan13Features32;
2124
2125 typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD32
2126 {
2127     VkStructureType sType;
2128     void *pNext;
2129     VkBool32 deviceCoherentMemory;
2130 } VkPhysicalDeviceCoherentMemoryFeaturesAMD32;
2131
2132 typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT32
2133 {
2134     VkStructureType sType;
2135     void *pNext;
2136     VkBool32 customBorderColors;
2137     VkBool32 customBorderColorWithoutFormat;
2138 } VkPhysicalDeviceCustomBorderColorFeaturesEXT32;
2139
2140 typedef struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32
2141 {
2142     VkStructureType sType;
2143     void *pNext;
2144     VkBool32 borderColorSwizzle;
2145     VkBool32 borderColorSwizzleFromImage;
2146 } VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32;
2147
2148 typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32
2149 {
2150     VkStructureType sType;
2151     void *pNext;
2152     VkBool32 extendedDynamicState;
2153 } VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32;
2154
2155 typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32
2156 {
2157     VkStructureType sType;
2158     void *pNext;
2159     VkBool32 extendedDynamicState2;
2160     VkBool32 extendedDynamicState2LogicOp;
2161     VkBool32 extendedDynamicState2PatchControlPoints;
2162 } VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32;
2163
2164 typedef struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32
2165 {
2166     VkStructureType sType;
2167     void *pNext;
2168     VkBool32 extendedDynamicState3TessellationDomainOrigin;
2169     VkBool32 extendedDynamicState3DepthClampEnable;
2170     VkBool32 extendedDynamicState3PolygonMode;
2171     VkBool32 extendedDynamicState3RasterizationSamples;
2172     VkBool32 extendedDynamicState3SampleMask;
2173     VkBool32 extendedDynamicState3AlphaToCoverageEnable;
2174     VkBool32 extendedDynamicState3AlphaToOneEnable;
2175     VkBool32 extendedDynamicState3LogicOpEnable;
2176     VkBool32 extendedDynamicState3ColorBlendEnable;
2177     VkBool32 extendedDynamicState3ColorBlendEquation;
2178     VkBool32 extendedDynamicState3ColorWriteMask;
2179     VkBool32 extendedDynamicState3RasterizationStream;
2180     VkBool32 extendedDynamicState3ConservativeRasterizationMode;
2181     VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize;
2182     VkBool32 extendedDynamicState3DepthClipEnable;
2183     VkBool32 extendedDynamicState3SampleLocationsEnable;
2184     VkBool32 extendedDynamicState3ColorBlendAdvanced;
2185     VkBool32 extendedDynamicState3ProvokingVertexMode;
2186     VkBool32 extendedDynamicState3LineRasterizationMode;
2187     VkBool32 extendedDynamicState3LineStippleEnable;
2188     VkBool32 extendedDynamicState3DepthClipNegativeOneToOne;
2189     VkBool32 extendedDynamicState3ViewportWScalingEnable;
2190     VkBool32 extendedDynamicState3ViewportSwizzle;
2191     VkBool32 extendedDynamicState3CoverageToColorEnable;
2192     VkBool32 extendedDynamicState3CoverageToColorLocation;
2193     VkBool32 extendedDynamicState3CoverageModulationMode;
2194     VkBool32 extendedDynamicState3CoverageModulationTableEnable;
2195     VkBool32 extendedDynamicState3CoverageModulationTable;
2196     VkBool32 extendedDynamicState3CoverageReductionMode;
2197     VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable;
2198     VkBool32 extendedDynamicState3ShadingRateImageEnable;
2199 } VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32;
2200
2201 typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV32
2202 {
2203     VkStructureType sType;
2204     void *pNext;
2205     VkBool32 diagnosticsConfig;
2206 } VkPhysicalDeviceDiagnosticsConfigFeaturesNV32;
2207
2208 typedef struct VkDeviceDiagnosticsConfigCreateInfoNV32
2209 {
2210     VkStructureType sType;
2211     const void *pNext;
2212     VkDeviceDiagnosticsConfigFlagsNV flags;
2213 } VkDeviceDiagnosticsConfigCreateInfoNV32;
2214
2215 typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32
2216 {
2217     VkStructureType sType;
2218     void *pNext;
2219     VkBool32 shaderZeroInitializeWorkgroupMemory;
2220 } VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32;
2221 typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR32;
2222
2223 typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32
2224 {
2225     VkStructureType sType;
2226     void *pNext;
2227     VkBool32 shaderSubgroupUniformControlFlow;
2228 } VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32;
2229
2230 typedef struct VkPhysicalDeviceRobustness2FeaturesEXT32
2231 {
2232     VkStructureType sType;
2233     void *pNext;
2234     VkBool32 robustBufferAccess2;
2235     VkBool32 robustImageAccess2;
2236     VkBool32 nullDescriptor;
2237 } VkPhysicalDeviceRobustness2FeaturesEXT32;
2238
2239 typedef struct VkPhysicalDeviceImageRobustnessFeatures32
2240 {
2241     VkStructureType sType;
2242     void *pNext;
2243     VkBool32 robustImageAccess;
2244 } VkPhysicalDeviceImageRobustnessFeatures32;
2245 typedef VkPhysicalDeviceImageRobustnessFeatures32 VkPhysicalDeviceImageRobustnessFeaturesEXT32;
2246
2247 typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32
2248 {
2249     VkStructureType sType;
2250     void *pNext;
2251     VkBool32 workgroupMemoryExplicitLayout;
2252     VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout;
2253     VkBool32 workgroupMemoryExplicitLayout8BitAccess;
2254     VkBool32 workgroupMemoryExplicitLayout16BitAccess;
2255 } VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32;
2256
2257 typedef struct VkPhysicalDevice4444FormatsFeaturesEXT32
2258 {
2259     VkStructureType sType;
2260     void *pNext;
2261     VkBool32 formatA4R4G4B4;
2262     VkBool32 formatA4B4G4R4;
2263 } VkPhysicalDevice4444FormatsFeaturesEXT32;
2264
2265 typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32
2266 {
2267     VkStructureType sType;
2268     void *pNext;
2269     VkBool32 subpassShading;
2270 } VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32;
2271
2272 typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32
2273 {
2274     VkStructureType sType;
2275     void *pNext;
2276     VkBool32 shaderImageInt64Atomics;
2277     VkBool32 sparseImageInt64Atomics;
2278 } VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32;
2279
2280 typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR32
2281 {
2282     VkStructureType sType;
2283     void *pNext;
2284     VkBool32 pipelineFragmentShadingRate;
2285     VkBool32 primitiveFragmentShadingRate;
2286     VkBool32 attachmentFragmentShadingRate;
2287 } VkPhysicalDeviceFragmentShadingRateFeaturesKHR32;
2288
2289 typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures32
2290 {
2291     VkStructureType sType;
2292     void *pNext;
2293     VkBool32 shaderTerminateInvocation;
2294 } VkPhysicalDeviceShaderTerminateInvocationFeatures32;
2295 typedef VkPhysicalDeviceShaderTerminateInvocationFeatures32 VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR32;
2296
2297 typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32
2298 {
2299     VkStructureType sType;
2300     void *pNext;
2301     VkBool32 fragmentShadingRateEnums;
2302     VkBool32 supersampleFragmentShadingRates;
2303     VkBool32 noInvocationFragmentShadingRates;
2304 } VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32;
2305
2306 typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32
2307 {
2308     VkStructureType sType;
2309     void *pNext;
2310     VkBool32 image2DViewOf3D;
2311     VkBool32 sampler2DViewOf3D;
2312 } VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32;
2313
2314 typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32
2315 {
2316     VkStructureType sType;
2317     void *pNext;
2318     VkBool32 mutableDescriptorType;
2319 } VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32;
2320 typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE32;
2321
2322 typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT32
2323 {
2324     VkStructureType sType;
2325     void *pNext;
2326     VkBool32 depthClipControl;
2327 } VkPhysicalDeviceDepthClipControlFeaturesEXT32;
2328
2329 typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32
2330 {
2331     VkStructureType sType;
2332     void *pNext;
2333     VkBool32 vertexInputDynamicState;
2334 } VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32;
2335
2336 typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT32
2337 {
2338     VkStructureType sType;
2339     void *pNext;
2340     VkBool32 colorWriteEnable;
2341 } VkPhysicalDeviceColorWriteEnableFeaturesEXT32;
2342
2343 typedef struct VkPhysicalDeviceSynchronization2Features32
2344 {
2345     VkStructureType sType;
2346     void *pNext;
2347     VkBool32 synchronization2;
2348 } VkPhysicalDeviceSynchronization2Features32;
2349 typedef VkPhysicalDeviceSynchronization2Features32 VkPhysicalDeviceSynchronization2FeaturesKHR32;
2350
2351 typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32
2352 {
2353     VkStructureType sType;
2354     void *pNext;
2355     VkBool32 primitivesGeneratedQuery;
2356     VkBool32 primitivesGeneratedQueryWithRasterizerDiscard;
2357     VkBool32 primitivesGeneratedQueryWithNonZeroStreams;
2358 } VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32;
2359
2360 typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT32
2361 {
2362     VkStructureType sType;
2363     void *pNext;
2364     VkBool32 legacyDithering;
2365 } VkPhysicalDeviceLegacyDitheringFeaturesEXT32;
2366
2367 typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32
2368 {
2369     VkStructureType sType;
2370     void *pNext;
2371     VkBool32 multisampledRenderToSingleSampled;
2372 } VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32;
2373
2374 typedef struct VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32
2375 {
2376     VkStructureType sType;
2377     void *pNext;
2378     VkBool32 pipelineProtectedAccess;
2379 } VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32;
2380
2381 typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV32
2382 {
2383     VkStructureType sType;
2384     void *pNext;
2385     VkBool32 inheritedViewportScissor2D;
2386 } VkPhysicalDeviceInheritedViewportScissorFeaturesNV32;
2387
2388 typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32
2389 {
2390     VkStructureType sType;
2391     void *pNext;
2392     VkBool32 ycbcr2plane444Formats;
2393 } VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32;
2394
2395 typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT32
2396 {
2397     VkStructureType sType;
2398     void *pNext;
2399     VkBool32 provokingVertexLast;
2400     VkBool32 transformFeedbackPreservesProvokingVertex;
2401 } VkPhysicalDeviceProvokingVertexFeaturesEXT32;
2402
2403 typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures32
2404 {
2405     VkStructureType sType;
2406     void *pNext;
2407     VkBool32 shaderIntegerDotProduct;
2408 } VkPhysicalDeviceShaderIntegerDotProductFeatures32;
2409 typedef VkPhysicalDeviceShaderIntegerDotProductFeatures32 VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR32;
2410
2411 typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32
2412 {
2413     VkStructureType sType;
2414     void *pNext;
2415     VkBool32 fragmentShaderBarycentric;
2416 } VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32;
2417 typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV32;
2418
2419 typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32
2420 {
2421     VkStructureType sType;
2422     void *pNext;
2423     VkBool32 rayTracingMotionBlur;
2424     VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect;
2425 } VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32;
2426
2427 typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32
2428 {
2429     VkStructureType sType;
2430     void *pNext;
2431     VkBool32 formatRgba10x6WithoutYCbCrSampler;
2432 } VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32;
2433
2434 typedef struct VkPhysicalDeviceDynamicRenderingFeatures32
2435 {
2436     VkStructureType sType;
2437     void *pNext;
2438     VkBool32 dynamicRendering;
2439 } VkPhysicalDeviceDynamicRenderingFeatures32;
2440 typedef VkPhysicalDeviceDynamicRenderingFeatures32 VkPhysicalDeviceDynamicRenderingFeaturesKHR32;
2441
2442 typedef struct VkPhysicalDeviceImageViewMinLodFeaturesEXT32
2443 {
2444     VkStructureType sType;
2445     void *pNext;
2446     VkBool32 minLod;
2447 } VkPhysicalDeviceImageViewMinLodFeaturesEXT32;
2448
2449 typedef struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32
2450 {
2451     VkStructureType sType;
2452     void *pNext;
2453     VkBool32 rasterizationOrderColorAttachmentAccess;
2454     VkBool32 rasterizationOrderDepthAttachmentAccess;
2455     VkBool32 rasterizationOrderStencilAttachmentAccess;
2456 } VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32;
2457 typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM32;
2458
2459 typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV32
2460 {
2461     VkStructureType sType;
2462     void *pNext;
2463     VkBool32 linearColorAttachment;
2464 } VkPhysicalDeviceLinearColorAttachmentFeaturesNV32;
2465
2466 typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32
2467 {
2468     VkStructureType sType;
2469     void *pNext;
2470     VkBool32 graphicsPipelineLibrary;
2471 } VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32;
2472
2473 typedef struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32
2474 {
2475     VkStructureType sType;
2476     void *pNext;
2477     VkBool32 descriptorSetHostMapping;
2478 } VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32;
2479
2480 typedef struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32
2481 {
2482     VkStructureType sType;
2483     void *pNext;
2484     VkBool32 shaderModuleIdentifier;
2485 } VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32;
2486
2487 typedef struct VkPhysicalDeviceImageCompressionControlFeaturesEXT32
2488 {
2489     VkStructureType sType;
2490     void *pNext;
2491     VkBool32 imageCompressionControl;
2492 } VkPhysicalDeviceImageCompressionControlFeaturesEXT32;
2493
2494 typedef struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32
2495 {
2496     VkStructureType sType;
2497     void *pNext;
2498     VkBool32 imageCompressionControlSwapchain;
2499 } VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32;
2500
2501 typedef struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32
2502 {
2503     VkStructureType sType;
2504     void *pNext;
2505     VkBool32 subpassMergeFeedback;
2506 } VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32;
2507
2508 typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT32
2509 {
2510     VkStructureType sType;
2511     void *pNext;
2512     VkBool32 micromap;
2513     VkBool32 micromapCaptureReplay;
2514     VkBool32 micromapHostCommands;
2515 } VkPhysicalDeviceOpacityMicromapFeaturesEXT32;
2516
2517 typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT32
2518 {
2519     VkStructureType sType;
2520     void *pNext;
2521     VkBool32 pipelinePropertiesIdentifier;
2522 } VkPhysicalDevicePipelinePropertiesFeaturesEXT32;
2523
2524 typedef struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32
2525 {
2526     VkStructureType sType;
2527     void *pNext;
2528     VkBool32 shaderEarlyAndLateFragmentTests;
2529 } VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32;
2530
2531 typedef struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32
2532 {
2533     VkStructureType sType;
2534     void *pNext;
2535     VkBool32 nonSeamlessCubeMap;
2536 } VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32;
2537
2538 typedef struct VkPhysicalDevicePipelineRobustnessFeaturesEXT32
2539 {
2540     VkStructureType sType;
2541     void *pNext;
2542     VkBool32 pipelineRobustness;
2543 } VkPhysicalDevicePipelineRobustnessFeaturesEXT32;
2544
2545 typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM32
2546 {
2547     VkStructureType sType;
2548     void *pNext;
2549     VkBool32 textureSampleWeighted;
2550     VkBool32 textureBoxFilter;
2551     VkBool32 textureBlockMatch;
2552 } VkPhysicalDeviceImageProcessingFeaturesQCOM32;
2553
2554 typedef struct VkPhysicalDeviceTilePropertiesFeaturesQCOM32
2555 {
2556     VkStructureType sType;
2557     void *pNext;
2558     VkBool32 tileProperties;
2559 } VkPhysicalDeviceTilePropertiesFeaturesQCOM32;
2560
2561 typedef struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32
2562 {
2563     VkStructureType sType;
2564     void *pNext;
2565     VkBool32 attachmentFeedbackLoopLayout;
2566 } VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32;
2567
2568 typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32
2569 {
2570     VkStructureType sType;
2571     void *pNext;
2572     VkBool32 depthClampZeroOne;
2573 } VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32;
2574
2575 typedef struct VkPhysicalDeviceAddressBindingReportFeaturesEXT32
2576 {
2577     VkStructureType sType;
2578     void *pNext;
2579     VkBool32 reportAddressBinding;
2580 } VkPhysicalDeviceAddressBindingReportFeaturesEXT32;
2581
2582 typedef struct VkPhysicalDeviceOpticalFlowFeaturesNV32
2583 {
2584     VkStructureType sType;
2585     void *pNext;
2586     VkBool32 opticalFlow;
2587 } VkPhysicalDeviceOpticalFlowFeaturesNV32;
2588
2589 typedef struct VkPhysicalDeviceFaultFeaturesEXT32
2590 {
2591     VkStructureType sType;
2592     void *pNext;
2593     VkBool32 deviceFault;
2594     VkBool32 deviceFaultVendorBinary;
2595 } VkPhysicalDeviceFaultFeaturesEXT32;
2596
2597 typedef struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32
2598 {
2599     VkStructureType sType;
2600     void *pNext;
2601     VkBool32 shaderCoreBuiltins;
2602 } VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32;
2603
2604 typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32
2605 {
2606     VkStructureType sType;
2607     void *pNext;
2608     VkBool32 rayTracingInvocationReorder;
2609 } VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32;
2610
2611 typedef struct VkDeviceCreateInfo32
2612 {
2613     VkStructureType sType;
2614     const void *pNext;
2615     VkDeviceCreateFlags flags;
2616     uint32_t queueCreateInfoCount;
2617     const VkDeviceQueueCreateInfo32 *pQueueCreateInfos;
2618     uint32_t enabledLayerCount;
2619     const char * const*ppEnabledLayerNames;
2620     uint32_t enabledExtensionCount;
2621     const char * const*ppEnabledExtensionNames;
2622     const VkPhysicalDeviceFeatures *pEnabledFeatures;
2623 } VkDeviceCreateInfo32;
2624
2625 typedef struct VkEventCreateInfo32
2626 {
2627     VkStructureType sType;
2628     const void *pNext;
2629     VkEventCreateFlags flags;
2630 } VkEventCreateInfo32;
2631
2632 typedef struct VkExportFenceCreateInfo32
2633 {
2634     VkStructureType sType;
2635     const void *pNext;
2636     VkExternalFenceHandleTypeFlags handleTypes;
2637 } VkExportFenceCreateInfo32;
2638 typedef VkExportFenceCreateInfo32 VkExportFenceCreateInfoKHR32;
2639
2640 typedef struct VkFenceCreateInfo32
2641 {
2642     VkStructureType sType;
2643     const void *pNext;
2644     VkFenceCreateFlags flags;
2645 } VkFenceCreateInfo32;
2646
2647 typedef struct VkFramebufferAttachmentImageInfo32
2648 {
2649     VkStructureType sType;
2650     const void *pNext;
2651     VkImageCreateFlags flags;
2652     VkImageUsageFlags usage;
2653     uint32_t width;
2654     uint32_t height;
2655     uint32_t layerCount;
2656     uint32_t viewFormatCount;
2657     const VkFormat *pViewFormats;
2658 } VkFramebufferAttachmentImageInfo32;
2659 typedef VkFramebufferAttachmentImageInfo32 VkFramebufferAttachmentImageInfoKHR32;
2660
2661 typedef struct VkFramebufferAttachmentsCreateInfo32
2662 {
2663     VkStructureType sType;
2664     const void *pNext;
2665     uint32_t attachmentImageInfoCount;
2666     const VkFramebufferAttachmentImageInfo32 *pAttachmentImageInfos;
2667 } VkFramebufferAttachmentsCreateInfo32;
2668 typedef VkFramebufferAttachmentsCreateInfo32 VkFramebufferAttachmentsCreateInfoKHR32;
2669
2670 typedef struct VkFramebufferCreateInfo32
2671 {
2672     VkStructureType sType;
2673     const void *pNext;
2674     VkFramebufferCreateFlags flags;
2675     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
2676     uint32_t attachmentCount;
2677     const VkImageView *pAttachments;
2678     uint32_t width;
2679     uint32_t height;
2680     uint32_t layers;
2681 } VkFramebufferCreateInfo32;
2682
2683 typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT32
2684 {
2685     VkStructureType sType;
2686     const void *pNext;
2687     uint32_t vertexBindingDivisorCount;
2688     const VkVertexInputBindingDivisorDescriptionEXT *pVertexBindingDivisors;
2689 } VkPipelineVertexInputDivisorStateCreateInfoEXT32;
2690
2691 typedef struct VkPipelineVertexInputStateCreateInfo32
2692 {
2693     VkStructureType sType;
2694     const void *pNext;
2695     VkPipelineVertexInputStateCreateFlags flags;
2696     uint32_t vertexBindingDescriptionCount;
2697     const VkVertexInputBindingDescription *pVertexBindingDescriptions;
2698     uint32_t vertexAttributeDescriptionCount;
2699     const VkVertexInputAttributeDescription *pVertexAttributeDescriptions;
2700 } VkPipelineVertexInputStateCreateInfo32;
2701
2702 typedef struct VkPipelineTessellationDomainOriginStateCreateInfo32
2703 {
2704     VkStructureType sType;
2705     const void *pNext;
2706     VkTessellationDomainOrigin domainOrigin;
2707 } VkPipelineTessellationDomainOriginStateCreateInfo32;
2708 typedef VkPipelineTessellationDomainOriginStateCreateInfo32 VkPipelineTessellationDomainOriginStateCreateInfoKHR32;
2709
2710 typedef struct VkPipelineTessellationStateCreateInfo32
2711 {
2712     VkStructureType sType;
2713     const void *pNext;
2714     VkPipelineTessellationStateCreateFlags flags;
2715     uint32_t patchControlPoints;
2716 } VkPipelineTessellationStateCreateInfo32;
2717
2718 typedef struct VkGraphicsShaderGroupCreateInfoNV32
2719 {
2720     VkStructureType sType;
2721     const void *pNext;
2722     uint32_t stageCount;
2723     const VkPipelineShaderStageCreateInfo32 *pStages;
2724     const VkPipelineVertexInputStateCreateInfo32 *pVertexInputState;
2725     const VkPipelineTessellationStateCreateInfo32 *pTessellationState;
2726 } VkGraphicsShaderGroupCreateInfoNV32;
2727
2728 typedef struct VkPipelineInputAssemblyStateCreateInfo32
2729 {
2730     VkStructureType sType;
2731     const void *pNext;
2732     VkPipelineInputAssemblyStateCreateFlags flags;
2733     VkPrimitiveTopology topology;
2734     VkBool32 primitiveRestartEnable;
2735 } VkPipelineInputAssemblyStateCreateInfo32;
2736
2737 typedef struct VkPipelineViewportWScalingStateCreateInfoNV32
2738 {
2739     VkStructureType sType;
2740     const void *pNext;
2741     VkBool32 viewportWScalingEnable;
2742     uint32_t viewportCount;
2743     const VkViewportWScalingNV *pViewportWScalings;
2744 } VkPipelineViewportWScalingStateCreateInfoNV32;
2745
2746 typedef struct VkPipelineViewportSwizzleStateCreateInfoNV32
2747 {
2748     VkStructureType sType;
2749     const void *pNext;
2750     VkPipelineViewportSwizzleStateCreateFlagsNV flags;
2751     uint32_t viewportCount;
2752     const VkViewportSwizzleNV *pViewportSwizzles;
2753 } VkPipelineViewportSwizzleStateCreateInfoNV32;
2754
2755 typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV32
2756 {
2757     VkStructureType sType;
2758     const void *pNext;
2759     uint32_t exclusiveScissorCount;
2760     const VkRect2D *pExclusiveScissors;
2761 } VkPipelineViewportExclusiveScissorStateCreateInfoNV32;
2762
2763 typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV32
2764 {
2765     VkStructureType sType;
2766     const void *pNext;
2767     VkBool32 shadingRateImageEnable;
2768     uint32_t viewportCount;
2769     const VkShadingRatePaletteNV *pShadingRatePalettes;
2770 } VkPipelineViewportShadingRateImageStateCreateInfoNV32;
2771
2772 typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32
2773 {
2774     VkStructureType sType;
2775     const void *pNext;
2776     VkCoarseSampleOrderTypeNV sampleOrderType;
2777     uint32_t customSampleOrderCount;
2778     const VkCoarseSampleOrderCustomNV *pCustomSampleOrders;
2779 } VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32;
2780
2781 typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT32
2782 {
2783     VkStructureType sType;
2784     const void *pNext;
2785     VkBool32 negativeOneToOne;
2786 } VkPipelineViewportDepthClipControlCreateInfoEXT32;
2787
2788 typedef struct VkPipelineViewportStateCreateInfo32
2789 {
2790     VkStructureType sType;
2791     const void *pNext;
2792     VkPipelineViewportStateCreateFlags flags;
2793     uint32_t viewportCount;
2794     const VkViewport *pViewports;
2795     uint32_t scissorCount;
2796     const VkRect2D *pScissors;
2797 } VkPipelineViewportStateCreateInfo32;
2798
2799 typedef struct VkPipelineRasterizationStateRasterizationOrderAMD32
2800 {
2801     VkStructureType sType;
2802     const void *pNext;
2803     VkRasterizationOrderAMD rasterizationOrder;
2804 } VkPipelineRasterizationStateRasterizationOrderAMD32;
2805
2806 typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT32
2807 {
2808     VkStructureType sType;
2809     const void *pNext;
2810     VkPipelineRasterizationConservativeStateCreateFlagsEXT flags;
2811     VkConservativeRasterizationModeEXT conservativeRasterizationMode;
2812     float extraPrimitiveOverestimationSize;
2813 } VkPipelineRasterizationConservativeStateCreateInfoEXT32;
2814
2815 typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT32
2816 {
2817     VkStructureType sType;
2818     const void *pNext;
2819     VkPipelineRasterizationStateStreamCreateFlagsEXT flags;
2820     uint32_t rasterizationStream;
2821 } VkPipelineRasterizationStateStreamCreateInfoEXT32;
2822
2823 typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT32
2824 {
2825     VkStructureType sType;
2826     const void *pNext;
2827     VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags;
2828     VkBool32 depthClipEnable;
2829 } VkPipelineRasterizationDepthClipStateCreateInfoEXT32;
2830
2831 typedef struct VkPipelineRasterizationLineStateCreateInfoEXT32
2832 {
2833     VkStructureType sType;
2834     const void *pNext;
2835     VkLineRasterizationModeEXT lineRasterizationMode;
2836     VkBool32 stippledLineEnable;
2837     uint32_t lineStippleFactor;
2838     uint16_t lineStipplePattern;
2839 } VkPipelineRasterizationLineStateCreateInfoEXT32;
2840
2841 typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32
2842 {
2843     VkStructureType sType;
2844     const void *pNext;
2845     VkProvokingVertexModeEXT provokingVertexMode;
2846 } VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32;
2847
2848 typedef struct VkPipelineRasterizationStateCreateInfo32
2849 {
2850     VkStructureType sType;
2851     const void *pNext;
2852     VkPipelineRasterizationStateCreateFlags flags;
2853     VkBool32 depthClampEnable;
2854     VkBool32 rasterizerDiscardEnable;
2855     VkPolygonMode polygonMode;
2856     VkCullModeFlags cullMode;
2857     VkFrontFace frontFace;
2858     VkBool32 depthBiasEnable;
2859     float depthBiasConstantFactor;
2860     float depthBiasClamp;
2861     float depthBiasSlopeFactor;
2862     float lineWidth;
2863 } VkPipelineRasterizationStateCreateInfo32;
2864
2865 typedef struct VkPipelineCoverageToColorStateCreateInfoNV32
2866 {
2867     VkStructureType sType;
2868     const void *pNext;
2869     VkPipelineCoverageToColorStateCreateFlagsNV flags;
2870     VkBool32 coverageToColorEnable;
2871     uint32_t coverageToColorLocation;
2872 } VkPipelineCoverageToColorStateCreateInfoNV32;
2873
2874 typedef struct VkPipelineSampleLocationsStateCreateInfoEXT32
2875 {
2876     VkStructureType sType;
2877     const void *pNext;
2878     VkBool32 sampleLocationsEnable;
2879     VkSampleLocationsInfoEXT32 sampleLocationsInfo;
2880 } VkPipelineSampleLocationsStateCreateInfoEXT32;
2881
2882 typedef struct VkPipelineCoverageModulationStateCreateInfoNV32
2883 {
2884     VkStructureType sType;
2885     const void *pNext;
2886     VkPipelineCoverageModulationStateCreateFlagsNV flags;
2887     VkCoverageModulationModeNV coverageModulationMode;
2888     VkBool32 coverageModulationTableEnable;
2889     uint32_t coverageModulationTableCount;
2890     const float *pCoverageModulationTable;
2891 } VkPipelineCoverageModulationStateCreateInfoNV32;
2892
2893 typedef struct VkPipelineCoverageReductionStateCreateInfoNV32
2894 {
2895     VkStructureType sType;
2896     const void *pNext;
2897     VkPipelineCoverageReductionStateCreateFlagsNV flags;
2898     VkCoverageReductionModeNV coverageReductionMode;
2899 } VkPipelineCoverageReductionStateCreateInfoNV32;
2900
2901 typedef struct VkPipelineMultisampleStateCreateInfo32
2902 {
2903     VkStructureType sType;
2904     const void *pNext;
2905     VkPipelineMultisampleStateCreateFlags flags;
2906     VkSampleCountFlagBits rasterizationSamples;
2907     VkBool32 sampleShadingEnable;
2908     float minSampleShading;
2909     const VkSampleMask *pSampleMask;
2910     VkBool32 alphaToCoverageEnable;
2911     VkBool32 alphaToOneEnable;
2912 } VkPipelineMultisampleStateCreateInfo32;
2913
2914 typedef struct VkPipelineDepthStencilStateCreateInfo32
2915 {
2916     VkStructureType sType;
2917     const void *pNext;
2918     VkPipelineDepthStencilStateCreateFlags flags;
2919     VkBool32 depthTestEnable;
2920     VkBool32 depthWriteEnable;
2921     VkCompareOp depthCompareOp;
2922     VkBool32 depthBoundsTestEnable;
2923     VkBool32 stencilTestEnable;
2924     VkStencilOpState front;
2925     VkStencilOpState back;
2926     float minDepthBounds;
2927     float maxDepthBounds;
2928 } VkPipelineDepthStencilStateCreateInfo32;
2929
2930 typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT32
2931 {
2932     VkStructureType sType;
2933     const void *pNext;
2934     VkBool32 srcPremultiplied;
2935     VkBool32 dstPremultiplied;
2936     VkBlendOverlapEXT blendOverlap;
2937 } VkPipelineColorBlendAdvancedStateCreateInfoEXT32;
2938
2939 typedef struct VkPipelineColorWriteCreateInfoEXT32
2940 {
2941     VkStructureType sType;
2942     const void *pNext;
2943     uint32_t attachmentCount;
2944     const VkBool32 *pColorWriteEnables;
2945 } VkPipelineColorWriteCreateInfoEXT32;
2946
2947 typedef struct VkPipelineColorBlendStateCreateInfo32
2948 {
2949     VkStructureType sType;
2950     const void *pNext;
2951     VkPipelineColorBlendStateCreateFlags flags;
2952     VkBool32 logicOpEnable;
2953     VkLogicOp logicOp;
2954     uint32_t attachmentCount;
2955     const VkPipelineColorBlendAttachmentState *pAttachments;
2956     float blendConstants[4];
2957 } VkPipelineColorBlendStateCreateInfo32;
2958
2959 typedef struct VkPipelineDynamicStateCreateInfo32
2960 {
2961     VkStructureType sType;
2962     const void *pNext;
2963     VkPipelineDynamicStateCreateFlags flags;
2964     uint32_t dynamicStateCount;
2965     const VkDynamicState *pDynamicStates;
2966 } VkPipelineDynamicStateCreateInfo32;
2967
2968 typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV32
2969 {
2970     VkStructureType sType;
2971     const void *pNext;
2972     uint32_t groupCount;
2973     const VkGraphicsShaderGroupCreateInfoNV32 *pGroups;
2974     uint32_t pipelineCount;
2975     const VkPipeline *pPipelines;
2976 } VkGraphicsPipelineShaderGroupsCreateInfoNV32;
2977
2978 typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT32
2979 {
2980     VkStructureType sType;
2981     const void *pNext;
2982     VkPipelineDiscardRectangleStateCreateFlagsEXT flags;
2983     VkDiscardRectangleModeEXT discardRectangleMode;
2984     uint32_t discardRectangleCount;
2985     const VkRect2D *pDiscardRectangles;
2986 } VkPipelineDiscardRectangleStateCreateInfoEXT32;
2987
2988 typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV32
2989 {
2990     VkStructureType sType;
2991     const void *pNext;
2992     VkBool32 representativeFragmentTestEnable;
2993 } VkPipelineRepresentativeFragmentTestStateCreateInfoNV32;
2994
2995 typedef struct VkPipelineLibraryCreateInfoKHR32
2996 {
2997     VkStructureType sType;
2998     const void *pNext;
2999     uint32_t libraryCount;
3000     const VkPipeline *pLibraries;
3001 } VkPipelineLibraryCreateInfoKHR32;
3002
3003 typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR32
3004 {
3005     VkStructureType sType;
3006     const void *pNext;
3007     VkExtent2D fragmentSize;
3008     VkFragmentShadingRateCombinerOpKHR combinerOps[2];
3009 } VkPipelineFragmentShadingRateStateCreateInfoKHR32;
3010
3011 typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV32
3012 {
3013     VkStructureType sType;
3014     const void *pNext;
3015     VkFragmentShadingRateTypeNV shadingRateType;
3016     VkFragmentShadingRateNV shadingRate;
3017     VkFragmentShadingRateCombinerOpKHR combinerOps[2];
3018 } VkPipelineFragmentShadingRateEnumStateCreateInfoNV32;
3019
3020 typedef struct VkPipelineRenderingCreateInfo32
3021 {
3022     VkStructureType sType;
3023     const void *pNext;
3024     uint32_t viewMask;
3025     uint32_t colorAttachmentCount;
3026     const VkFormat *pColorAttachmentFormats;
3027     VkFormat depthAttachmentFormat;
3028     VkFormat stencilAttachmentFormat;
3029 } VkPipelineRenderingCreateInfo32;
3030 typedef VkPipelineRenderingCreateInfo32 VkPipelineRenderingCreateInfoKHR32;
3031
3032 typedef struct VkGraphicsPipelineLibraryCreateInfoEXT32
3033 {
3034     VkStructureType sType;
3035     void *pNext;
3036     VkGraphicsPipelineLibraryFlagsEXT flags;
3037 } VkGraphicsPipelineLibraryCreateInfoEXT32;
3038
3039 typedef struct VkGraphicsPipelineCreateInfo32
3040 {
3041     VkStructureType sType;
3042     const void *pNext;
3043     VkPipelineCreateFlags flags;
3044     uint32_t stageCount;
3045     const VkPipelineShaderStageCreateInfo32 *pStages;
3046     const VkPipelineVertexInputStateCreateInfo32 *pVertexInputState;
3047     const VkPipelineInputAssemblyStateCreateInfo32 *pInputAssemblyState;
3048     const VkPipelineTessellationStateCreateInfo32 *pTessellationState;
3049     const VkPipelineViewportStateCreateInfo32 *pViewportState;
3050     const VkPipelineRasterizationStateCreateInfo32 *pRasterizationState;
3051     const VkPipelineMultisampleStateCreateInfo32 *pMultisampleState;
3052     const VkPipelineDepthStencilStateCreateInfo32 *pDepthStencilState;
3053     const VkPipelineColorBlendStateCreateInfo32 *pColorBlendState;
3054     const VkPipelineDynamicStateCreateInfo32 *pDynamicState;
3055     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
3056     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
3057     uint32_t subpass;
3058     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
3059     int32_t basePipelineIndex;
3060 } VkGraphicsPipelineCreateInfo32;
3061
3062 typedef struct VkDedicatedAllocationImageCreateInfoNV32
3063 {
3064     VkStructureType sType;
3065     const void *pNext;
3066     VkBool32 dedicatedAllocation;
3067 } VkDedicatedAllocationImageCreateInfoNV32;
3068
3069 typedef struct VkExternalMemoryImageCreateInfo32
3070 {
3071     VkStructureType sType;
3072     const void *pNext;
3073     VkExternalMemoryHandleTypeFlags handleTypes;
3074 } VkExternalMemoryImageCreateInfo32;
3075 typedef VkExternalMemoryImageCreateInfo32 VkExternalMemoryImageCreateInfoKHR32;
3076
3077 typedef struct VkImageSwapchainCreateInfoKHR32
3078 {
3079     VkStructureType sType;
3080     const void *pNext;
3081     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
3082 } VkImageSwapchainCreateInfoKHR32;
3083
3084 typedef struct VkImageFormatListCreateInfo32
3085 {
3086     VkStructureType sType;
3087     const void *pNext;
3088     uint32_t viewFormatCount;
3089     const VkFormat *pViewFormats;
3090 } VkImageFormatListCreateInfo32;
3091 typedef VkImageFormatListCreateInfo32 VkImageFormatListCreateInfoKHR32;
3092
3093 typedef struct VkImageStencilUsageCreateInfo32
3094 {
3095     VkStructureType sType;
3096     const void *pNext;
3097     VkImageUsageFlags stencilUsage;
3098 } VkImageStencilUsageCreateInfo32;
3099 typedef VkImageStencilUsageCreateInfo32 VkImageStencilUsageCreateInfoEXT32;
3100
3101 typedef struct VkImageCompressionControlEXT32
3102 {
3103     VkStructureType sType;
3104     const void *pNext;
3105     VkImageCompressionFlagsEXT flags;
3106     uint32_t compressionControlPlaneCount;
3107     VkImageCompressionFixedRateFlagsEXT *pFixedRateFlags;
3108 } VkImageCompressionControlEXT32;
3109
3110 typedef struct VkOpticalFlowImageFormatInfoNV32
3111 {
3112     VkStructureType sType;
3113     const void *pNext;
3114     VkOpticalFlowUsageFlagsNV usage;
3115 } VkOpticalFlowImageFormatInfoNV32;
3116
3117 typedef struct VkImageCreateInfo32
3118 {
3119     VkStructureType sType;
3120     const void *pNext;
3121     VkImageCreateFlags flags;
3122     VkImageType imageType;
3123     VkFormat format;
3124     VkExtent3D extent;
3125     uint32_t mipLevels;
3126     uint32_t arrayLayers;
3127     VkSampleCountFlagBits samples;
3128     VkImageTiling tiling;
3129     VkImageUsageFlags usage;
3130     VkSharingMode sharingMode;
3131     uint32_t queueFamilyIndexCount;
3132     const uint32_t *pQueueFamilyIndices;
3133     VkImageLayout initialLayout;
3134 } VkImageCreateInfo32;
3135
3136 typedef struct VkImageViewUsageCreateInfo32
3137 {
3138     VkStructureType sType;
3139     const void *pNext;
3140     VkImageUsageFlags usage;
3141 } VkImageViewUsageCreateInfo32;
3142 typedef VkImageViewUsageCreateInfo32 VkImageViewUsageCreateInfoKHR32;
3143
3144 typedef struct VkSamplerYcbcrConversionInfo32
3145 {
3146     VkStructureType sType;
3147     const void *pNext;
3148     VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) conversion;
3149 } VkSamplerYcbcrConversionInfo32;
3150 typedef VkSamplerYcbcrConversionInfo32 VkSamplerYcbcrConversionInfoKHR32;
3151
3152 typedef struct VkImageViewASTCDecodeModeEXT32
3153 {
3154     VkStructureType sType;
3155     const void *pNext;
3156     VkFormat decodeMode;
3157 } VkImageViewASTCDecodeModeEXT32;
3158
3159 typedef struct VkImageViewMinLodCreateInfoEXT32
3160 {
3161     VkStructureType sType;
3162     const void *pNext;
3163     float minLod;
3164 } VkImageViewMinLodCreateInfoEXT32;
3165
3166 typedef struct VkImageViewSampleWeightCreateInfoQCOM32
3167 {
3168     VkStructureType sType;
3169     const void *pNext;
3170     VkOffset2D filterCenter;
3171     VkExtent2D filterSize;
3172     uint32_t numPhases;
3173 } VkImageViewSampleWeightCreateInfoQCOM32;
3174
3175 typedef struct VkImageViewCreateInfo32
3176 {
3177     VkStructureType sType;
3178     const void *pNext;
3179     VkImageViewCreateFlags flags;
3180     VkImage DECLSPEC_ALIGN(8) image;
3181     VkImageViewType viewType;
3182     VkFormat format;
3183     VkComponentMapping components;
3184     VkImageSubresourceRange subresourceRange;
3185 } VkImageViewCreateInfo32;
3186
3187 typedef struct VkIndirectCommandsLayoutTokenNV32
3188 {
3189     VkStructureType sType;
3190     const void *pNext;
3191     VkIndirectCommandsTokenTypeNV tokenType;
3192     uint32_t stream;
3193     uint32_t offset;
3194     uint32_t vertexBindingUnit;
3195     VkBool32 vertexDynamicStride;
3196     VkPipelineLayout DECLSPEC_ALIGN(8) pushconstantPipelineLayout;
3197     VkShaderStageFlags pushconstantShaderStageFlags;
3198     uint32_t pushconstantOffset;
3199     uint32_t pushconstantSize;
3200     VkIndirectStateFlagsNV indirectStateFlags;
3201     uint32_t indexTypeCount;
3202     const VkIndexType *pIndexTypes;
3203     const uint32_t *pIndexTypeValues;
3204 } VkIndirectCommandsLayoutTokenNV32;
3205
3206 typedef struct VkIndirectCommandsLayoutCreateInfoNV32
3207 {
3208     VkStructureType sType;
3209     const void *pNext;
3210     VkIndirectCommandsLayoutUsageFlagsNV flags;
3211     VkPipelineBindPoint pipelineBindPoint;
3212     uint32_t tokenCount;
3213     const VkIndirectCommandsLayoutTokenNV32 *pTokens;
3214     uint32_t streamCount;
3215     const uint32_t *pStreamStrides;
3216 } VkIndirectCommandsLayoutCreateInfoNV32;
3217
3218 typedef struct VkApplicationInfo32
3219 {
3220     VkStructureType sType;
3221     const void *pNext;
3222     const char *pApplicationName;
3223     uint32_t applicationVersion;
3224     const char *pEngineName;
3225     uint32_t engineVersion;
3226     uint32_t apiVersion;
3227 } VkApplicationInfo32;
3228
3229 typedef struct VkValidationFlagsEXT32
3230 {
3231     VkStructureType sType;
3232     const void *pNext;
3233     uint32_t disabledValidationCheckCount;
3234     const VkValidationCheckEXT *pDisabledValidationChecks;
3235 } VkValidationFlagsEXT32;
3236
3237 typedef struct VkValidationFeaturesEXT32
3238 {
3239     VkStructureType sType;
3240     const void *pNext;
3241     uint32_t enabledValidationFeatureCount;
3242     const VkValidationFeatureEnableEXT *pEnabledValidationFeatures;
3243     uint32_t disabledValidationFeatureCount;
3244     const VkValidationFeatureDisableEXT *pDisabledValidationFeatures;
3245 } VkValidationFeaturesEXT32;
3246
3247 typedef struct VkInstanceCreateInfo32
3248 {
3249     VkStructureType sType;
3250     const void *pNext;
3251     VkInstanceCreateFlags flags;
3252     const VkApplicationInfo32 *pApplicationInfo;
3253     uint32_t enabledLayerCount;
3254     const char * const*ppEnabledLayerNames;
3255     uint32_t enabledExtensionCount;
3256     const char * const*ppEnabledExtensionNames;
3257 } VkInstanceCreateInfo32;
3258
3259 typedef struct VkMicromapCreateInfoEXT32
3260 {
3261     VkStructureType sType;
3262     const void *pNext;
3263     VkMicromapCreateFlagsEXT createFlags;
3264     VkBuffer DECLSPEC_ALIGN(8) buffer;
3265     VkDeviceSize DECLSPEC_ALIGN(8) offset;
3266     VkDeviceSize DECLSPEC_ALIGN(8) size;
3267     VkMicromapTypeEXT type;
3268     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
3269 } VkMicromapCreateInfoEXT32;
3270
3271 typedef struct VkOpticalFlowSessionCreatePrivateDataInfoNV32
3272 {
3273     VkStructureType sType;
3274     void *pNext;
3275     uint32_t id;
3276     uint32_t size;
3277     const void *pPrivateData;
3278 } VkOpticalFlowSessionCreatePrivateDataInfoNV32;
3279
3280 typedef struct VkOpticalFlowSessionCreateInfoNV32
3281 {
3282     VkStructureType sType;
3283     void *pNext;
3284     uint32_t width;
3285     uint32_t height;
3286     VkFormat imageFormat;
3287     VkFormat flowVectorFormat;
3288     VkFormat costFormat;
3289     VkOpticalFlowGridSizeFlagsNV outputGridSize;
3290     VkOpticalFlowGridSizeFlagsNV hintGridSize;
3291     VkOpticalFlowPerformanceLevelNV performanceLevel;
3292     VkOpticalFlowSessionCreateFlagsNV flags;
3293 } VkOpticalFlowSessionCreateInfoNV32;
3294
3295 typedef struct VkPipelineCacheCreateInfo32
3296 {
3297     VkStructureType sType;
3298     const void *pNext;
3299     VkPipelineCacheCreateFlags flags;
3300     size_t initialDataSize;
3301     const void *pInitialData;
3302 } VkPipelineCacheCreateInfo32;
3303
3304 typedef struct VkPipelineLayoutCreateInfo32
3305 {
3306     VkStructureType sType;
3307     const void *pNext;
3308     VkPipelineLayoutCreateFlags flags;
3309     uint32_t setLayoutCount;
3310     const VkDescriptorSetLayout *pSetLayouts;
3311     uint32_t pushConstantRangeCount;
3312     const VkPushConstantRange *pPushConstantRanges;
3313 } VkPipelineLayoutCreateInfo32;
3314
3315 typedef struct VkPrivateDataSlotCreateInfo32
3316 {
3317     VkStructureType sType;
3318     const void *pNext;
3319     VkPrivateDataSlotCreateFlags flags;
3320 } VkPrivateDataSlotCreateInfo32;
3321 typedef VkPrivateDataSlotCreateInfo32 VkPrivateDataSlotCreateInfoEXT32;
3322
3323 typedef struct VkQueryPoolPerformanceCreateInfoKHR32
3324 {
3325     VkStructureType sType;
3326     const void *pNext;
3327     uint32_t queueFamilyIndex;
3328     uint32_t counterIndexCount;
3329     const uint32_t *pCounterIndices;
3330 } VkQueryPoolPerformanceCreateInfoKHR32;
3331
3332 typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL32
3333 {
3334     VkStructureType sType;
3335     const void *pNext;
3336     VkQueryPoolSamplingModeINTEL performanceCountersSampling;
3337 } VkQueryPoolPerformanceQueryCreateInfoINTEL32;
3338 typedef VkQueryPoolPerformanceQueryCreateInfoINTEL32 VkQueryPoolCreateInfoINTEL32;
3339
3340 typedef struct VkQueryPoolCreateInfo32
3341 {
3342     VkStructureType sType;
3343     const void *pNext;
3344     VkQueryPoolCreateFlags flags;
3345     VkQueryType queryType;
3346     uint32_t queryCount;
3347     VkQueryPipelineStatisticFlags pipelineStatistics;
3348 } VkQueryPoolCreateInfo32;
3349
3350 typedef struct VkRayTracingShaderGroupCreateInfoKHR32
3351 {
3352     VkStructureType sType;
3353     const void *pNext;
3354     VkRayTracingShaderGroupTypeKHR type;
3355     uint32_t generalShader;
3356     uint32_t closestHitShader;
3357     uint32_t anyHitShader;
3358     uint32_t intersectionShader;
3359     const void *pShaderGroupCaptureReplayHandle;
3360 } VkRayTracingShaderGroupCreateInfoKHR32;
3361
3362 typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR32
3363 {
3364     VkStructureType sType;
3365     const void *pNext;
3366     uint32_t maxPipelineRayPayloadSize;
3367     uint32_t maxPipelineRayHitAttributeSize;
3368 } VkRayTracingPipelineInterfaceCreateInfoKHR32;
3369
3370 typedef struct VkRayTracingPipelineCreateInfoKHR32
3371 {
3372     VkStructureType sType;
3373     const void *pNext;
3374     VkPipelineCreateFlags flags;
3375     uint32_t stageCount;
3376     const VkPipelineShaderStageCreateInfo32 *pStages;
3377     uint32_t groupCount;
3378     const VkRayTracingShaderGroupCreateInfoKHR32 *pGroups;
3379     uint32_t maxPipelineRayRecursionDepth;
3380     const VkPipelineLibraryCreateInfoKHR32 *pLibraryInfo;
3381     const VkRayTracingPipelineInterfaceCreateInfoKHR32 *pLibraryInterface;
3382     const VkPipelineDynamicStateCreateInfo32 *pDynamicState;
3383     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
3384     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
3385     int32_t basePipelineIndex;
3386 } VkRayTracingPipelineCreateInfoKHR32;
3387
3388 typedef struct VkRayTracingShaderGroupCreateInfoNV32
3389 {
3390     VkStructureType sType;
3391     const void *pNext;
3392     VkRayTracingShaderGroupTypeKHR type;
3393     uint32_t generalShader;
3394     uint32_t closestHitShader;
3395     uint32_t anyHitShader;
3396     uint32_t intersectionShader;
3397 } VkRayTracingShaderGroupCreateInfoNV32;
3398
3399 typedef struct VkRayTracingPipelineCreateInfoNV32
3400 {
3401     VkStructureType sType;
3402     const void *pNext;
3403     VkPipelineCreateFlags flags;
3404     uint32_t stageCount;
3405     const VkPipelineShaderStageCreateInfo32 *pStages;
3406     uint32_t groupCount;
3407     const VkRayTracingShaderGroupCreateInfoNV32 *pGroups;
3408     uint32_t maxRecursionDepth;
3409     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
3410     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
3411     int32_t basePipelineIndex;
3412 } VkRayTracingPipelineCreateInfoNV32;
3413
3414 typedef struct VkRenderPassMultiviewCreateInfo32
3415 {
3416     VkStructureType sType;
3417     const void *pNext;
3418     uint32_t subpassCount;
3419     const uint32_t *pViewMasks;
3420     uint32_t dependencyCount;
3421     const int32_t *pViewOffsets;
3422     uint32_t correlationMaskCount;
3423     const uint32_t *pCorrelationMasks;
3424 } VkRenderPassMultiviewCreateInfo32;
3425 typedef VkRenderPassMultiviewCreateInfo32 VkRenderPassMultiviewCreateInfoKHR32;
3426
3427 typedef struct VkRenderPassInputAttachmentAspectCreateInfo32
3428 {
3429     VkStructureType sType;
3430     const void *pNext;
3431     uint32_t aspectReferenceCount;
3432     const VkInputAttachmentAspectReference *pAspectReferences;
3433 } VkRenderPassInputAttachmentAspectCreateInfo32;
3434 typedef VkRenderPassInputAttachmentAspectCreateInfo32 VkRenderPassInputAttachmentAspectCreateInfoKHR32;
3435
3436 typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT32
3437 {
3438     VkStructureType sType;
3439     const void *pNext;
3440     VkAttachmentReference fragmentDensityMapAttachment;
3441 } VkRenderPassFragmentDensityMapCreateInfoEXT32;
3442
3443 typedef struct VkRenderPassCreateInfo32
3444 {
3445     VkStructureType sType;
3446     const void *pNext;
3447     VkRenderPassCreateFlags flags;
3448     uint32_t attachmentCount;
3449     const VkAttachmentDescription *pAttachments;
3450     uint32_t subpassCount;
3451     const VkSubpassDescription *pSubpasses;
3452     uint32_t dependencyCount;
3453     const VkSubpassDependency *pDependencies;
3454 } VkRenderPassCreateInfo32;
3455
3456 typedef struct VkAttachmentDescriptionStencilLayout32
3457 {
3458     VkStructureType sType;
3459     void *pNext;
3460     VkImageLayout stencilInitialLayout;
3461     VkImageLayout stencilFinalLayout;
3462 } VkAttachmentDescriptionStencilLayout32;
3463 typedef VkAttachmentDescriptionStencilLayout32 VkAttachmentDescriptionStencilLayoutKHR32;
3464
3465 typedef struct VkAttachmentDescription232
3466 {
3467     VkStructureType sType;
3468     const void *pNext;
3469     VkAttachmentDescriptionFlags flags;
3470     VkFormat format;
3471     VkSampleCountFlagBits samples;
3472     VkAttachmentLoadOp loadOp;
3473     VkAttachmentStoreOp storeOp;
3474     VkAttachmentLoadOp stencilLoadOp;
3475     VkAttachmentStoreOp stencilStoreOp;
3476     VkImageLayout initialLayout;
3477     VkImageLayout finalLayout;
3478 } VkAttachmentDescription232;
3479 typedef VkAttachmentDescription232 VkAttachmentDescription2KHR32;
3480
3481 typedef struct VkAttachmentReferenceStencilLayout32
3482 {
3483     VkStructureType sType;
3484     void *pNext;
3485     VkImageLayout stencilLayout;
3486 } VkAttachmentReferenceStencilLayout32;
3487 typedef VkAttachmentReferenceStencilLayout32 VkAttachmentReferenceStencilLayoutKHR32;
3488
3489 typedef struct VkAttachmentReference232
3490 {
3491     VkStructureType sType;
3492     const void *pNext;
3493     uint32_t attachment;
3494     VkImageLayout layout;
3495     VkImageAspectFlags aspectMask;
3496 } VkAttachmentReference232;
3497 typedef VkAttachmentReference232 VkAttachmentReference2KHR32;
3498
3499 typedef struct VkSubpassDescriptionDepthStencilResolve32
3500 {
3501     VkStructureType sType;
3502     const void *pNext;
3503     VkResolveModeFlagBits depthResolveMode;
3504     VkResolveModeFlagBits stencilResolveMode;
3505     const VkAttachmentReference232 *pDepthStencilResolveAttachment;
3506 } VkSubpassDescriptionDepthStencilResolve32;
3507 typedef VkSubpassDescriptionDepthStencilResolve32 VkSubpassDescriptionDepthStencilResolveKHR32;
3508
3509 typedef struct VkFragmentShadingRateAttachmentInfoKHR32
3510 {
3511     VkStructureType sType;
3512     const void *pNext;
3513     const VkAttachmentReference232 *pFragmentShadingRateAttachment;
3514     VkExtent2D shadingRateAttachmentTexelSize;
3515 } VkFragmentShadingRateAttachmentInfoKHR32;
3516
3517 typedef struct VkRenderPassCreationControlEXT32
3518 {
3519     VkStructureType sType;
3520     const void *pNext;
3521     VkBool32 disallowMerging;
3522 } VkRenderPassCreationControlEXT32;
3523
3524 typedef struct VkRenderPassSubpassFeedbackCreateInfoEXT32
3525 {
3526     VkStructureType sType;
3527     const void *pNext;
3528     VkRenderPassSubpassFeedbackInfoEXT *pSubpassFeedback;
3529 } VkRenderPassSubpassFeedbackCreateInfoEXT32;
3530
3531 typedef struct VkSubpassDescription232
3532 {
3533     VkStructureType sType;
3534     const void *pNext;
3535     VkSubpassDescriptionFlags flags;
3536     VkPipelineBindPoint pipelineBindPoint;
3537     uint32_t viewMask;
3538     uint32_t inputAttachmentCount;
3539     const VkAttachmentReference232 *pInputAttachments;
3540     uint32_t colorAttachmentCount;
3541     const VkAttachmentReference232 *pColorAttachments;
3542     const VkAttachmentReference232 *pResolveAttachments;
3543     const VkAttachmentReference232 *pDepthStencilAttachment;
3544     uint32_t preserveAttachmentCount;
3545     const uint32_t *pPreserveAttachments;
3546 } VkSubpassDescription232;
3547 typedef VkSubpassDescription232 VkSubpassDescription2KHR32;
3548
3549 typedef struct VkSubpassDependency232
3550 {
3551     VkStructureType sType;
3552     const void *pNext;
3553     uint32_t srcSubpass;
3554     uint32_t dstSubpass;
3555     VkPipelineStageFlags srcStageMask;
3556     VkPipelineStageFlags dstStageMask;
3557     VkAccessFlags srcAccessMask;
3558     VkAccessFlags dstAccessMask;
3559     VkDependencyFlags dependencyFlags;
3560     int32_t viewOffset;
3561 } VkSubpassDependency232;
3562 typedef VkSubpassDependency232 VkSubpassDependency2KHR32;
3563
3564 typedef struct VkRenderPassCreationFeedbackCreateInfoEXT32
3565 {
3566     VkStructureType sType;
3567     const void *pNext;
3568     VkRenderPassCreationFeedbackInfoEXT *pRenderPassFeedback;
3569 } VkRenderPassCreationFeedbackCreateInfoEXT32;
3570
3571 typedef struct VkRenderPassCreateInfo232
3572 {
3573     VkStructureType sType;
3574     const void *pNext;
3575     VkRenderPassCreateFlags flags;
3576     uint32_t attachmentCount;
3577     const VkAttachmentDescription232 *pAttachments;
3578     uint32_t subpassCount;
3579     const VkSubpassDescription232 *pSubpasses;
3580     uint32_t dependencyCount;
3581     const VkSubpassDependency232 *pDependencies;
3582     uint32_t correlatedViewMaskCount;
3583     const uint32_t *pCorrelatedViewMasks;
3584 } VkRenderPassCreateInfo232;
3585 typedef VkRenderPassCreateInfo232 VkRenderPassCreateInfo2KHR32;
3586
3587 typedef struct VkSamplerReductionModeCreateInfo32
3588 {
3589     VkStructureType sType;
3590     const void *pNext;
3591     VkSamplerReductionMode reductionMode;
3592 } VkSamplerReductionModeCreateInfo32;
3593 typedef VkSamplerReductionModeCreateInfo32 VkSamplerReductionModeCreateInfoEXT32;
3594
3595 typedef struct VkSamplerCustomBorderColorCreateInfoEXT32
3596 {
3597     VkStructureType sType;
3598     const void *pNext;
3599     VkClearColorValue customBorderColor;
3600     VkFormat format;
3601 } VkSamplerCustomBorderColorCreateInfoEXT32;
3602
3603 typedef struct VkSamplerBorderColorComponentMappingCreateInfoEXT32
3604 {
3605     VkStructureType sType;
3606     const void *pNext;
3607     VkComponentMapping components;
3608     VkBool32 srgb;
3609 } VkSamplerBorderColorComponentMappingCreateInfoEXT32;
3610
3611 typedef struct VkSamplerCreateInfo32
3612 {
3613     VkStructureType sType;
3614     const void *pNext;
3615     VkSamplerCreateFlags flags;
3616     VkFilter magFilter;
3617     VkFilter minFilter;
3618     VkSamplerMipmapMode mipmapMode;
3619     VkSamplerAddressMode addressModeU;
3620     VkSamplerAddressMode addressModeV;
3621     VkSamplerAddressMode addressModeW;
3622     float mipLodBias;
3623     VkBool32 anisotropyEnable;
3624     float maxAnisotropy;
3625     VkBool32 compareEnable;
3626     VkCompareOp compareOp;
3627     float minLod;
3628     float maxLod;
3629     VkBorderColor borderColor;
3630     VkBool32 unnormalizedCoordinates;
3631 } VkSamplerCreateInfo32;
3632
3633 typedef struct VkSamplerYcbcrConversionCreateInfo32
3634 {
3635     VkStructureType sType;
3636     const void *pNext;
3637     VkFormat format;
3638     VkSamplerYcbcrModelConversion ycbcrModel;
3639     VkSamplerYcbcrRange ycbcrRange;
3640     VkComponentMapping components;
3641     VkChromaLocation xChromaOffset;
3642     VkChromaLocation yChromaOffset;
3643     VkFilter chromaFilter;
3644     VkBool32 forceExplicitReconstruction;
3645 } VkSamplerYcbcrConversionCreateInfo32;
3646 typedef VkSamplerYcbcrConversionCreateInfo32 VkSamplerYcbcrConversionCreateInfoKHR32;
3647
3648 typedef struct VkExportSemaphoreCreateInfo32
3649 {
3650     VkStructureType sType;
3651     const void *pNext;
3652     VkExternalSemaphoreHandleTypeFlags handleTypes;
3653 } VkExportSemaphoreCreateInfo32;
3654 typedef VkExportSemaphoreCreateInfo32 VkExportSemaphoreCreateInfoKHR32;
3655
3656 typedef struct VkSemaphoreTypeCreateInfo32
3657 {
3658     VkStructureType sType;
3659     const void *pNext;
3660     VkSemaphoreType semaphoreType;
3661     uint64_t DECLSPEC_ALIGN(8) initialValue;
3662 } VkSemaphoreTypeCreateInfo32;
3663 typedef VkSemaphoreTypeCreateInfo32 VkSemaphoreTypeCreateInfoKHR32;
3664
3665 typedef struct VkSemaphoreCreateInfo32
3666 {
3667     VkStructureType sType;
3668     const void *pNext;
3669     VkSemaphoreCreateFlags flags;
3670 } VkSemaphoreCreateInfo32;
3671
3672 typedef struct VkDeviceGroupSwapchainCreateInfoKHR32
3673 {
3674     VkStructureType sType;
3675     const void *pNext;
3676     VkDeviceGroupPresentModeFlagsKHR modes;
3677 } VkDeviceGroupSwapchainCreateInfoKHR32;
3678
3679 typedef struct VkSwapchainPresentBarrierCreateInfoNV32
3680 {
3681     VkStructureType sType;
3682     void *pNext;
3683     VkBool32 presentBarrierEnable;
3684 } VkSwapchainPresentBarrierCreateInfoNV32;
3685
3686 typedef struct VkSwapchainCreateInfoKHR32
3687 {
3688     VkStructureType sType;
3689     const void *pNext;
3690     VkSwapchainCreateFlagsKHR flags;
3691     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
3692     uint32_t minImageCount;
3693     VkFormat imageFormat;
3694     VkColorSpaceKHR imageColorSpace;
3695     VkExtent2D imageExtent;
3696     uint32_t imageArrayLayers;
3697     VkImageUsageFlags imageUsage;
3698     VkSharingMode imageSharingMode;
3699     uint32_t queueFamilyIndexCount;
3700     const uint32_t *pQueueFamilyIndices;
3701     VkSurfaceTransformFlagBitsKHR preTransform;
3702     VkCompositeAlphaFlagBitsKHR compositeAlpha;
3703     VkPresentModeKHR presentMode;
3704     VkBool32 clipped;
3705     VkSwapchainKHR DECLSPEC_ALIGN(8) oldSwapchain;
3706 } VkSwapchainCreateInfoKHR32;
3707
3708 typedef struct VkValidationCacheCreateInfoEXT32
3709 {
3710     VkStructureType sType;
3711     const void *pNext;
3712     VkValidationCacheCreateFlagsEXT flags;
3713     size_t initialDataSize;
3714     const void *pInitialData;
3715 } VkValidationCacheCreateInfoEXT32;
3716
3717 typedef struct VkWin32SurfaceCreateInfoKHR32
3718 {
3719     VkStructureType sType;
3720     const void *pNext;
3721     VkWin32SurfaceCreateFlagsKHR flags;
3722     HINSTANCE hinstance;
3723     HWND hwnd;
3724 } VkWin32SurfaceCreateInfoKHR32;
3725
3726 typedef struct VkDebugMarkerObjectNameInfoEXT32
3727 {
3728     VkStructureType sType;
3729     const void *pNext;
3730     VkDebugReportObjectTypeEXT objectType;
3731     uint64_t DECLSPEC_ALIGN(8) object;
3732     const char *pObjectName;
3733 } VkDebugMarkerObjectNameInfoEXT32;
3734
3735 typedef struct VkDebugMarkerObjectTagInfoEXT32
3736 {
3737     VkStructureType sType;
3738     const void *pNext;
3739     VkDebugReportObjectTypeEXT objectType;
3740     uint64_t DECLSPEC_ALIGN(8) object;
3741     uint64_t DECLSPEC_ALIGN(8) tagName;
3742     size_t tagSize;
3743     const void *pTag;
3744 } VkDebugMarkerObjectTagInfoEXT32;
3745
3746 typedef struct VkPhysicalDeviceGroupProperties32
3747 {
3748     VkStructureType sType;
3749     void *pNext;
3750     uint32_t physicalDeviceCount;
3751     VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
3752     VkBool32 subsetAllocation;
3753 } VkPhysicalDeviceGroupProperties32;
3754 typedef VkPhysicalDeviceGroupProperties32 VkPhysicalDeviceGroupPropertiesKHR32;
3755
3756 typedef struct VkPerformanceCounterKHR32
3757 {
3758     VkStructureType sType;
3759     void *pNext;
3760     VkPerformanceCounterUnitKHR unit;
3761     VkPerformanceCounterScopeKHR scope;
3762     VkPerformanceCounterStorageKHR storage;
3763     uint8_t uuid[VK_UUID_SIZE];
3764 } VkPerformanceCounterKHR32;
3765
3766 typedef struct VkPerformanceCounterDescriptionKHR32
3767 {
3768     VkStructureType sType;
3769     void *pNext;
3770     VkPerformanceCounterDescriptionFlagsKHR flags;
3771     char name[VK_MAX_DESCRIPTION_SIZE];
3772     char category[VK_MAX_DESCRIPTION_SIZE];
3773     char description[VK_MAX_DESCRIPTION_SIZE];
3774 } VkPerformanceCounterDescriptionKHR32;
3775
3776 typedef struct VkMappedMemoryRange32
3777 {
3778     VkStructureType sType;
3779     const void *pNext;
3780     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
3781     VkDeviceSize DECLSPEC_ALIGN(8) offset;
3782     VkDeviceSize DECLSPEC_ALIGN(8) size;
3783 } VkMappedMemoryRange32;
3784
3785 typedef struct VkAccelerationStructureBuildSizesInfoKHR32
3786 {
3787     VkStructureType sType;
3788     const void *pNext;
3789     VkDeviceSize DECLSPEC_ALIGN(8) accelerationStructureSize;
3790     VkDeviceSize DECLSPEC_ALIGN(8) updateScratchSize;
3791     VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize;
3792 } VkAccelerationStructureBuildSizesInfoKHR32;
3793
3794 typedef struct VkAccelerationStructureDeviceAddressInfoKHR32
3795 {
3796     VkStructureType sType;
3797     const void *pNext;
3798     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
3799 } VkAccelerationStructureDeviceAddressInfoKHR32;
3800
3801 typedef struct VkAccelerationStructureMemoryRequirementsInfoNV32
3802 {
3803     VkStructureType sType;
3804     const void *pNext;
3805     VkAccelerationStructureMemoryRequirementsTypeNV type;
3806     VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
3807 } VkAccelerationStructureMemoryRequirementsInfoNV32;
3808
3809 typedef struct VkMemoryRequirements32
3810 {
3811     VkDeviceSize DECLSPEC_ALIGN(8) size;
3812     VkDeviceSize DECLSPEC_ALIGN(8) alignment;
3813     uint32_t memoryTypeBits;
3814 } VkMemoryRequirements32;
3815
3816
3817 typedef struct VkBufferDeviceAddressInfo32
3818 {
3819     VkStructureType sType;
3820     const void *pNext;
3821     VkBuffer DECLSPEC_ALIGN(8) buffer;
3822 } VkBufferDeviceAddressInfo32;
3823 typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoKHR32;
3824 typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoEXT32;
3825
3826 typedef struct VkBufferMemoryRequirementsInfo232
3827 {
3828     VkStructureType sType;
3829     const void *pNext;
3830     VkBuffer DECLSPEC_ALIGN(8) buffer;
3831 } VkBufferMemoryRequirementsInfo232;
3832 typedef VkBufferMemoryRequirementsInfo232 VkBufferMemoryRequirementsInfo2KHR32;
3833
3834 typedef struct VkMemoryDedicatedRequirements32
3835 {
3836     VkStructureType sType;
3837     void *pNext;
3838     VkBool32 prefersDedicatedAllocation;
3839     VkBool32 requiresDedicatedAllocation;
3840 } VkMemoryDedicatedRequirements32;
3841 typedef VkMemoryDedicatedRequirements32 VkMemoryDedicatedRequirementsKHR32;
3842
3843 typedef struct VkMemoryRequirements232
3844 {
3845     VkStructureType sType;
3846     void *pNext;
3847     VkMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
3848 } VkMemoryRequirements232;
3849 typedef VkMemoryRequirements232 VkMemoryRequirements2KHR32;
3850
3851 typedef struct VkCalibratedTimestampInfoEXT32
3852 {
3853     VkStructureType sType;
3854     const void *pNext;
3855     VkTimeDomainEXT timeDomain;
3856 } VkCalibratedTimestampInfoEXT32;
3857
3858 typedef struct VkDescriptorSetBindingReferenceVALVE32
3859 {
3860     VkStructureType sType;
3861     const void *pNext;
3862     VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
3863     uint32_t binding;
3864 } VkDescriptorSetBindingReferenceVALVE32;
3865
3866 typedef struct VkDescriptorSetLayoutHostMappingInfoVALVE32
3867 {
3868     VkStructureType sType;
3869     void *pNext;
3870     size_t descriptorOffset;
3871     uint32_t descriptorSize;
3872 } VkDescriptorSetLayoutHostMappingInfoVALVE32;
3873
3874 typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport32
3875 {
3876     VkStructureType sType;
3877     void *pNext;
3878     uint32_t maxVariableDescriptorCount;
3879 } VkDescriptorSetVariableDescriptorCountLayoutSupport32;
3880 typedef VkDescriptorSetVariableDescriptorCountLayoutSupport32 VkDescriptorSetVariableDescriptorCountLayoutSupportEXT32;
3881
3882 typedef struct VkDescriptorSetLayoutSupport32
3883 {
3884     VkStructureType sType;
3885     void *pNext;
3886     VkBool32 supported;
3887 } VkDescriptorSetLayoutSupport32;
3888 typedef VkDescriptorSetLayoutSupport32 VkDescriptorSetLayoutSupportKHR32;
3889
3890 typedef struct VkAccelerationStructureVersionInfoKHR32
3891 {
3892     VkStructureType sType;
3893     const void *pNext;
3894     const uint8_t *pVersionData;
3895 } VkAccelerationStructureVersionInfoKHR32;
3896
3897 typedef struct VkDeviceBufferMemoryRequirements32
3898 {
3899     VkStructureType sType;
3900     const void *pNext;
3901     const VkBufferCreateInfo32 *pCreateInfo;
3902 } VkDeviceBufferMemoryRequirements32;
3903 typedef VkDeviceBufferMemoryRequirements32 VkDeviceBufferMemoryRequirementsKHR32;
3904
3905 typedef struct VkDeviceFaultCountsEXT32
3906 {
3907     VkStructureType sType;
3908     void *pNext;
3909     uint32_t addressInfoCount;
3910     uint32_t vendorInfoCount;
3911     VkDeviceSize DECLSPEC_ALIGN(8) vendorBinarySize;
3912 } VkDeviceFaultCountsEXT32;
3913
3914 typedef struct VkDeviceFaultAddressInfoEXT32
3915 {
3916     VkDeviceFaultAddressTypeEXT addressType;
3917     VkDeviceAddress DECLSPEC_ALIGN(8) reportedAddress;
3918     VkDeviceSize DECLSPEC_ALIGN(8) addressPrecision;
3919 } VkDeviceFaultAddressInfoEXT32;
3920
3921 typedef struct VkDeviceFaultVendorInfoEXT32
3922 {
3923     char description[VK_MAX_DESCRIPTION_SIZE];
3924     uint64_t DECLSPEC_ALIGN(8) vendorFaultCode;
3925     uint64_t DECLSPEC_ALIGN(8) vendorFaultData;
3926 } VkDeviceFaultVendorInfoEXT32;
3927
3928 typedef struct VkDeviceFaultInfoEXT32
3929 {
3930     VkStructureType sType;
3931     void *pNext;
3932     char description[VK_MAX_DESCRIPTION_SIZE];
3933     VkDeviceFaultAddressInfoEXT32 *pAddressInfos;
3934     VkDeviceFaultVendorInfoEXT32 *pVendorInfos;
3935     void *pVendorBinaryData;
3936 } VkDeviceFaultInfoEXT32;
3937
3938 typedef struct VkDeviceGroupPresentCapabilitiesKHR32
3939 {
3940     VkStructureType sType;
3941     void *pNext;
3942     uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
3943     VkDeviceGroupPresentModeFlagsKHR modes;
3944 } VkDeviceGroupPresentCapabilitiesKHR32;
3945
3946 typedef struct VkDeviceImageMemoryRequirements32
3947 {
3948     VkStructureType sType;
3949     const void *pNext;
3950     const VkImageCreateInfo32 *pCreateInfo;
3951     VkImageAspectFlagBits planeAspect;
3952 } VkDeviceImageMemoryRequirements32;
3953 typedef VkDeviceImageMemoryRequirements32 VkDeviceImageMemoryRequirementsKHR32;
3954
3955 typedef struct VkSparseImageMemoryRequirements32
3956 {
3957     VkSparseImageFormatProperties formatProperties;
3958     uint32_t imageMipTailFirstLod;
3959     VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailSize;
3960     VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailOffset;
3961     VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailStride;
3962 } VkSparseImageMemoryRequirements32;
3963
3964 typedef struct VkSparseImageMemoryRequirements232
3965 {
3966     VkStructureType sType;
3967     void *pNext;
3968     VkSparseImageMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
3969 } VkSparseImageMemoryRequirements232;
3970 typedef VkSparseImageMemoryRequirements232 VkSparseImageMemoryRequirements2KHR32;
3971
3972 typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo32
3973 {
3974     VkStructureType sType;
3975     const void *pNext;
3976     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
3977 } VkDeviceMemoryOpaqueCaptureAddressInfo32;
3978 typedef VkDeviceMemoryOpaqueCaptureAddressInfo32 VkDeviceMemoryOpaqueCaptureAddressInfoKHR32;
3979
3980 typedef struct VkMicromapVersionInfoEXT32
3981 {
3982     VkStructureType sType;
3983     const void *pNext;
3984     const uint8_t *pVersionData;
3985 } VkMicromapVersionInfoEXT32;
3986
3987 typedef struct VkDeviceQueueInfo232
3988 {
3989     VkStructureType sType;
3990     const void *pNext;
3991     VkDeviceQueueCreateFlags flags;
3992     uint32_t queueFamilyIndex;
3993     uint32_t queueIndex;
3994 } VkDeviceQueueInfo232;
3995
3996 typedef struct VkTilePropertiesQCOM32
3997 {
3998     VkStructureType sType;
3999     void *pNext;
4000     VkExtent3D tileSize;
4001     VkExtent2D apronSize;
4002     VkOffset2D origin;
4003 } VkTilePropertiesQCOM32;
4004
4005 typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV32
4006 {
4007     VkStructureType sType;
4008     const void *pNext;
4009     VkPipelineBindPoint pipelineBindPoint;
4010     VkPipeline DECLSPEC_ALIGN(8) pipeline;
4011     VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
4012     uint32_t maxSequencesCount;
4013 } VkGeneratedCommandsMemoryRequirementsInfoNV32;
4014
4015 typedef struct VkImagePlaneMemoryRequirementsInfo32
4016 {
4017     VkStructureType sType;
4018     const void *pNext;
4019     VkImageAspectFlagBits planeAspect;
4020 } VkImagePlaneMemoryRequirementsInfo32;
4021 typedef VkImagePlaneMemoryRequirementsInfo32 VkImagePlaneMemoryRequirementsInfoKHR32;
4022
4023 typedef struct VkImageMemoryRequirementsInfo232
4024 {
4025     VkStructureType sType;
4026     const void *pNext;
4027     VkImage DECLSPEC_ALIGN(8) image;
4028 } VkImageMemoryRequirementsInfo232;
4029 typedef VkImageMemoryRequirementsInfo232 VkImageMemoryRequirementsInfo2KHR32;
4030
4031 typedef struct VkImageSparseMemoryRequirementsInfo232
4032 {
4033     VkStructureType sType;
4034     const void *pNext;
4035     VkImage DECLSPEC_ALIGN(8) image;
4036 } VkImageSparseMemoryRequirementsInfo232;
4037 typedef VkImageSparseMemoryRequirementsInfo232 VkImageSparseMemoryRequirementsInfo2KHR32;
4038
4039 typedef struct VkSubresourceLayout32
4040 {
4041     VkDeviceSize DECLSPEC_ALIGN(8) offset;
4042     VkDeviceSize DECLSPEC_ALIGN(8) size;
4043     VkDeviceSize DECLSPEC_ALIGN(8) rowPitch;
4044     VkDeviceSize DECLSPEC_ALIGN(8) arrayPitch;
4045     VkDeviceSize DECLSPEC_ALIGN(8) depthPitch;
4046 } VkSubresourceLayout32;
4047
4048 typedef struct VkImageSubresource2EXT32
4049 {
4050     VkStructureType sType;
4051     void *pNext;
4052     VkImageSubresource imageSubresource;
4053 } VkImageSubresource2EXT32;
4054
4055 typedef struct VkImageCompressionPropertiesEXT32
4056 {
4057     VkStructureType sType;
4058     void *pNext;
4059     VkImageCompressionFlagsEXT imageCompressionFlags;
4060     VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags;
4061 } VkImageCompressionPropertiesEXT32;
4062
4063 typedef struct VkSubresourceLayout2EXT32
4064 {
4065     VkStructureType sType;
4066     void *pNext;
4067     VkSubresourceLayout32 DECLSPEC_ALIGN(8) subresourceLayout;
4068 } VkSubresourceLayout2EXT32;
4069
4070 typedef struct VkImageViewAddressPropertiesNVX32
4071 {
4072     VkStructureType sType;
4073     void *pNext;
4074     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
4075     VkDeviceSize DECLSPEC_ALIGN(8) size;
4076 } VkImageViewAddressPropertiesNVX32;
4077
4078 typedef struct VkImageViewHandleInfoNVX32
4079 {
4080     VkStructureType sType;
4081     const void *pNext;
4082     VkImageView DECLSPEC_ALIGN(8) imageView;
4083     VkDescriptorType descriptorType;
4084     VkSampler DECLSPEC_ALIGN(8) sampler;
4085 } VkImageViewHandleInfoNVX32;
4086
4087 typedef struct VkMemoryHostPointerPropertiesEXT32
4088 {
4089     VkStructureType sType;
4090     void *pNext;
4091     uint32_t memoryTypeBits;
4092 } VkMemoryHostPointerPropertiesEXT32;
4093
4094 typedef struct VkMicromapBuildSizesInfoEXT32
4095 {
4096     VkStructureType sType;
4097     const void *pNext;
4098     VkDeviceSize DECLSPEC_ALIGN(8) micromapSize;
4099     VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize;
4100     VkBool32 discardable;
4101 } VkMicromapBuildSizesInfoEXT32;
4102
4103 typedef struct VkPerformanceValueINTEL32
4104 {
4105     VkPerformanceValueTypeINTEL type;
4106     VkPerformanceValueDataINTEL DECLSPEC_ALIGN(8) data;
4107 } VkPerformanceValueINTEL32;
4108
4109 typedef struct VkCooperativeMatrixPropertiesNV32
4110 {
4111     VkStructureType sType;
4112     void *pNext;
4113     uint32_t MSize;
4114     uint32_t NSize;
4115     uint32_t KSize;
4116     VkComponentTypeNV AType;
4117     VkComponentTypeNV BType;
4118     VkComponentTypeNV CType;
4119     VkComponentTypeNV DType;
4120     VkScopeNV scope;
4121 } VkCooperativeMatrixPropertiesNV32;
4122
4123 typedef struct VkPhysicalDeviceExternalBufferInfo32
4124 {
4125     VkStructureType sType;
4126     const void *pNext;
4127     VkBufferCreateFlags flags;
4128     VkBufferUsageFlags usage;
4129     VkExternalMemoryHandleTypeFlagBits handleType;
4130 } VkPhysicalDeviceExternalBufferInfo32;
4131 typedef VkPhysicalDeviceExternalBufferInfo32 VkPhysicalDeviceExternalBufferInfoKHR32;
4132
4133 typedef struct VkExternalBufferProperties32
4134 {
4135     VkStructureType sType;
4136     void *pNext;
4137     VkExternalMemoryProperties externalMemoryProperties;
4138 } VkExternalBufferProperties32;
4139 typedef VkExternalBufferProperties32 VkExternalBufferPropertiesKHR32;
4140
4141 typedef struct VkPhysicalDeviceExternalFenceInfo32
4142 {
4143     VkStructureType sType;
4144     const void *pNext;
4145     VkExternalFenceHandleTypeFlagBits handleType;
4146 } VkPhysicalDeviceExternalFenceInfo32;
4147 typedef VkPhysicalDeviceExternalFenceInfo32 VkPhysicalDeviceExternalFenceInfoKHR32;
4148
4149 typedef struct VkExternalFenceProperties32
4150 {
4151     VkStructureType sType;
4152     void *pNext;
4153     VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
4154     VkExternalFenceHandleTypeFlags compatibleHandleTypes;
4155     VkExternalFenceFeatureFlags externalFenceFeatures;
4156 } VkExternalFenceProperties32;
4157 typedef VkExternalFenceProperties32 VkExternalFencePropertiesKHR32;
4158
4159 typedef struct VkPhysicalDeviceExternalSemaphoreInfo32
4160 {
4161     VkStructureType sType;
4162     const void *pNext;
4163     VkExternalSemaphoreHandleTypeFlagBits handleType;
4164 } VkPhysicalDeviceExternalSemaphoreInfo32;
4165 typedef VkPhysicalDeviceExternalSemaphoreInfo32 VkPhysicalDeviceExternalSemaphoreInfoKHR32;
4166
4167 typedef struct VkExternalSemaphoreProperties32
4168 {
4169     VkStructureType sType;
4170     void *pNext;
4171     VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
4172     VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
4173     VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
4174 } VkExternalSemaphoreProperties32;
4175 typedef VkExternalSemaphoreProperties32 VkExternalSemaphorePropertiesKHR32;
4176
4177 typedef struct VkSubpassResolvePerformanceQueryEXT32
4178 {
4179     VkStructureType sType;
4180     void *pNext;
4181     VkBool32 optimal;
4182 } VkSubpassResolvePerformanceQueryEXT32;
4183
4184 typedef struct VkFormatProperties332
4185 {
4186     VkStructureType sType;
4187     void *pNext;
4188     VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) linearTilingFeatures;
4189     VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) optimalTilingFeatures;
4190     VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) bufferFeatures;
4191 } VkFormatProperties332;
4192 typedef VkFormatProperties332 VkFormatProperties3KHR32;
4193
4194 typedef struct VkFormatProperties232
4195 {
4196     VkStructureType sType;
4197     void *pNext;
4198     VkFormatProperties formatProperties;
4199 } VkFormatProperties232;
4200 typedef VkFormatProperties232 VkFormatProperties2KHR32;
4201
4202 typedef struct VkPhysicalDeviceFragmentShadingRateKHR32
4203 {
4204     VkStructureType sType;
4205     void *pNext;
4206     VkSampleCountFlags sampleCounts;
4207     VkExtent2D fragmentSize;
4208 } VkPhysicalDeviceFragmentShadingRateKHR32;
4209
4210 typedef struct VkImageFormatProperties32
4211 {
4212     VkExtent3D maxExtent;
4213     uint32_t maxMipLevels;
4214     uint32_t maxArrayLayers;
4215     VkSampleCountFlags sampleCounts;
4216     VkDeviceSize DECLSPEC_ALIGN(8) maxResourceSize;
4217 } VkImageFormatProperties32;
4218
4219 typedef struct VkPhysicalDeviceExternalImageFormatInfo32
4220 {
4221     VkStructureType sType;
4222     const void *pNext;
4223     VkExternalMemoryHandleTypeFlagBits handleType;
4224 } VkPhysicalDeviceExternalImageFormatInfo32;
4225 typedef VkPhysicalDeviceExternalImageFormatInfo32 VkPhysicalDeviceExternalImageFormatInfoKHR32;
4226
4227 typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT32
4228 {
4229     VkStructureType sType;
4230     void *pNext;
4231     VkImageViewType imageViewType;
4232 } VkPhysicalDeviceImageViewImageFormatInfoEXT32;
4233
4234 typedef struct VkPhysicalDeviceImageFormatInfo232
4235 {
4236     VkStructureType sType;
4237     const void *pNext;
4238     VkFormat format;
4239     VkImageType type;
4240     VkImageTiling tiling;
4241     VkImageUsageFlags usage;
4242     VkImageCreateFlags flags;
4243 } VkPhysicalDeviceImageFormatInfo232;
4244 typedef VkPhysicalDeviceImageFormatInfo232 VkPhysicalDeviceImageFormatInfo2KHR32;
4245
4246 typedef struct VkExternalImageFormatProperties32
4247 {
4248     VkStructureType sType;
4249     void *pNext;
4250     VkExternalMemoryProperties externalMemoryProperties;
4251 } VkExternalImageFormatProperties32;
4252 typedef VkExternalImageFormatProperties32 VkExternalImageFormatPropertiesKHR32;
4253
4254 typedef struct VkSamplerYcbcrConversionImageFormatProperties32
4255 {
4256     VkStructureType sType;
4257     void *pNext;
4258     uint32_t combinedImageSamplerDescriptorCount;
4259 } VkSamplerYcbcrConversionImageFormatProperties32;
4260 typedef VkSamplerYcbcrConversionImageFormatProperties32 VkSamplerYcbcrConversionImageFormatPropertiesKHR32;
4261
4262 typedef struct VkTextureLODGatherFormatPropertiesAMD32
4263 {
4264     VkStructureType sType;
4265     void *pNext;
4266     VkBool32 supportsTextureGatherLODBiasAMD;
4267 } VkTextureLODGatherFormatPropertiesAMD32;
4268
4269 typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT32
4270 {
4271     VkStructureType sType;
4272     void *pNext;
4273     VkBool32 filterCubic;
4274     VkBool32 filterCubicMinmax;
4275 } VkFilterCubicImageViewImageFormatPropertiesEXT32;
4276
4277 typedef struct VkImageFormatProperties232
4278 {
4279     VkStructureType sType;
4280     void *pNext;
4281     VkImageFormatProperties32 DECLSPEC_ALIGN(8) imageFormatProperties;
4282 } VkImageFormatProperties232;
4283 typedef VkImageFormatProperties232 VkImageFormatProperties2KHR32;
4284
4285 typedef struct VkMemoryHeap32
4286 {
4287     VkDeviceSize DECLSPEC_ALIGN(8) size;
4288     VkMemoryHeapFlags flags;
4289 } VkMemoryHeap32;
4290
4291 typedef struct VkPhysicalDeviceMemoryProperties32
4292 {
4293     uint32_t memoryTypeCount;
4294     VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
4295     uint32_t memoryHeapCount;
4296     VkMemoryHeap32 DECLSPEC_ALIGN(8) memoryHeaps[VK_MAX_MEMORY_HEAPS];
4297 } VkPhysicalDeviceMemoryProperties32;
4298
4299 typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT32
4300 {
4301     VkStructureType sType;
4302     void *pNext;
4303     VkDeviceSize DECLSPEC_ALIGN(8) heapBudget[VK_MAX_MEMORY_HEAPS];
4304     VkDeviceSize DECLSPEC_ALIGN(8) heapUsage[VK_MAX_MEMORY_HEAPS];
4305 } VkPhysicalDeviceMemoryBudgetPropertiesEXT32;
4306
4307 typedef struct VkPhysicalDeviceMemoryProperties232
4308 {
4309     VkStructureType sType;
4310     void *pNext;
4311     VkPhysicalDeviceMemoryProperties32 DECLSPEC_ALIGN(8) memoryProperties;
4312 } VkPhysicalDeviceMemoryProperties232;
4313 typedef VkPhysicalDeviceMemoryProperties232 VkPhysicalDeviceMemoryProperties2KHR32;
4314
4315 typedef struct VkMultisamplePropertiesEXT32
4316 {
4317     VkStructureType sType;
4318     void *pNext;
4319     VkExtent2D maxSampleLocationGridSize;
4320 } VkMultisamplePropertiesEXT32;
4321
4322 typedef struct VkOpticalFlowImageFormatPropertiesNV32
4323 {
4324     VkStructureType sType;
4325     const void *pNext;
4326     VkFormat format;
4327 } VkOpticalFlowImageFormatPropertiesNV32;
4328
4329 typedef struct VkPhysicalDeviceLimits32
4330 {
4331     uint32_t maxImageDimension1D;
4332     uint32_t maxImageDimension2D;
4333     uint32_t maxImageDimension3D;
4334     uint32_t maxImageDimensionCube;
4335     uint32_t maxImageArrayLayers;
4336     uint32_t maxTexelBufferElements;
4337     uint32_t maxUniformBufferRange;
4338     uint32_t maxStorageBufferRange;
4339     uint32_t maxPushConstantsSize;
4340     uint32_t maxMemoryAllocationCount;
4341     uint32_t maxSamplerAllocationCount;
4342     VkDeviceSize DECLSPEC_ALIGN(8) bufferImageGranularity;
4343     VkDeviceSize DECLSPEC_ALIGN(8) sparseAddressSpaceSize;
4344     uint32_t maxBoundDescriptorSets;
4345     uint32_t maxPerStageDescriptorSamplers;
4346     uint32_t maxPerStageDescriptorUniformBuffers;
4347     uint32_t maxPerStageDescriptorStorageBuffers;
4348     uint32_t maxPerStageDescriptorSampledImages;
4349     uint32_t maxPerStageDescriptorStorageImages;
4350     uint32_t maxPerStageDescriptorInputAttachments;
4351     uint32_t maxPerStageResources;
4352     uint32_t maxDescriptorSetSamplers;
4353     uint32_t maxDescriptorSetUniformBuffers;
4354     uint32_t maxDescriptorSetUniformBuffersDynamic;
4355     uint32_t maxDescriptorSetStorageBuffers;
4356     uint32_t maxDescriptorSetStorageBuffersDynamic;
4357     uint32_t maxDescriptorSetSampledImages;
4358     uint32_t maxDescriptorSetStorageImages;
4359     uint32_t maxDescriptorSetInputAttachments;
4360     uint32_t maxVertexInputAttributes;
4361     uint32_t maxVertexInputBindings;
4362     uint32_t maxVertexInputAttributeOffset;
4363     uint32_t maxVertexInputBindingStride;
4364     uint32_t maxVertexOutputComponents;
4365     uint32_t maxTessellationGenerationLevel;
4366     uint32_t maxTessellationPatchSize;
4367     uint32_t maxTessellationControlPerVertexInputComponents;
4368     uint32_t maxTessellationControlPerVertexOutputComponents;
4369     uint32_t maxTessellationControlPerPatchOutputComponents;
4370     uint32_t maxTessellationControlTotalOutputComponents;
4371     uint32_t maxTessellationEvaluationInputComponents;
4372     uint32_t maxTessellationEvaluationOutputComponents;
4373     uint32_t maxGeometryShaderInvocations;
4374     uint32_t maxGeometryInputComponents;
4375     uint32_t maxGeometryOutputComponents;
4376     uint32_t maxGeometryOutputVertices;
4377     uint32_t maxGeometryTotalOutputComponents;
4378     uint32_t maxFragmentInputComponents;
4379     uint32_t maxFragmentOutputAttachments;
4380     uint32_t maxFragmentDualSrcAttachments;
4381     uint32_t maxFragmentCombinedOutputResources;
4382     uint32_t maxComputeSharedMemorySize;
4383     uint32_t maxComputeWorkGroupCount[3];
4384     uint32_t maxComputeWorkGroupInvocations;
4385     uint32_t maxComputeWorkGroupSize[3];
4386     uint32_t subPixelPrecisionBits;
4387     uint32_t subTexelPrecisionBits;
4388     uint32_t mipmapPrecisionBits;
4389     uint32_t maxDrawIndexedIndexValue;
4390     uint32_t maxDrawIndirectCount;
4391     float maxSamplerLodBias;
4392     float maxSamplerAnisotropy;
4393     uint32_t maxViewports;
4394     uint32_t maxViewportDimensions[2];
4395     float viewportBoundsRange[2];
4396     uint32_t viewportSubPixelBits;
4397     size_t minMemoryMapAlignment;
4398     VkDeviceSize DECLSPEC_ALIGN(8) minTexelBufferOffsetAlignment;
4399     VkDeviceSize DECLSPEC_ALIGN(8) minUniformBufferOffsetAlignment;
4400     VkDeviceSize DECLSPEC_ALIGN(8) minStorageBufferOffsetAlignment;
4401     int32_t minTexelOffset;
4402     uint32_t maxTexelOffset;
4403     int32_t minTexelGatherOffset;
4404     uint32_t maxTexelGatherOffset;
4405     float minInterpolationOffset;
4406     float maxInterpolationOffset;
4407     uint32_t subPixelInterpolationOffsetBits;
4408     uint32_t maxFramebufferWidth;
4409     uint32_t maxFramebufferHeight;
4410     uint32_t maxFramebufferLayers;
4411     VkSampleCountFlags framebufferColorSampleCounts;
4412     VkSampleCountFlags framebufferDepthSampleCounts;
4413     VkSampleCountFlags framebufferStencilSampleCounts;
4414     VkSampleCountFlags framebufferNoAttachmentsSampleCounts;
4415     uint32_t maxColorAttachments;
4416     VkSampleCountFlags sampledImageColorSampleCounts;
4417     VkSampleCountFlags sampledImageIntegerSampleCounts;
4418     VkSampleCountFlags sampledImageDepthSampleCounts;
4419     VkSampleCountFlags sampledImageStencilSampleCounts;
4420     VkSampleCountFlags storageImageSampleCounts;
4421     uint32_t maxSampleMaskWords;
4422     VkBool32 timestampComputeAndGraphics;
4423     float timestampPeriod;
4424     uint32_t maxClipDistances;
4425     uint32_t maxCullDistances;
4426     uint32_t maxCombinedClipAndCullDistances;
4427     uint32_t discreteQueuePriorities;
4428     float pointSizeRange[2];
4429     float lineWidthRange[2];
4430     float pointSizeGranularity;
4431     float lineWidthGranularity;
4432     VkBool32 strictLines;
4433     VkBool32 standardSampleLocations;
4434     VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyOffsetAlignment;
4435     VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyRowPitchAlignment;
4436     VkDeviceSize DECLSPEC_ALIGN(8) nonCoherentAtomSize;
4437 } VkPhysicalDeviceLimits32;
4438
4439 typedef struct VkPhysicalDeviceProperties32
4440 {
4441     uint32_t apiVersion;
4442     uint32_t driverVersion;
4443     uint32_t vendorID;
4444     uint32_t deviceID;
4445     VkPhysicalDeviceType deviceType;
4446     char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
4447     uint8_t pipelineCacheUUID[VK_UUID_SIZE];
4448     VkPhysicalDeviceLimits32 DECLSPEC_ALIGN(8) limits;
4449     VkPhysicalDeviceSparseProperties sparseProperties;
4450 } VkPhysicalDeviceProperties32;
4451
4452 typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32
4453 {
4454     VkStructureType sType;
4455     void *pNext;
4456     uint32_t maxGraphicsShaderGroupCount;
4457     uint32_t maxIndirectSequenceCount;
4458     uint32_t maxIndirectCommandsTokenCount;
4459     uint32_t maxIndirectCommandsStreamCount;
4460     uint32_t maxIndirectCommandsTokenOffset;
4461     uint32_t maxIndirectCommandsStreamStride;
4462     uint32_t minSequencesCountBufferOffsetAlignment;
4463     uint32_t minSequencesIndexBufferOffsetAlignment;
4464     uint32_t minIndirectCommandsBufferOffsetAlignment;
4465 } VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32;
4466
4467 typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT32
4468 {
4469     VkStructureType sType;
4470     void *pNext;
4471     uint32_t maxMultiDrawCount;
4472 } VkPhysicalDeviceMultiDrawPropertiesEXT32;
4473
4474 typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR32
4475 {
4476     VkStructureType sType;
4477     void *pNext;
4478     uint32_t maxPushDescriptors;
4479 } VkPhysicalDevicePushDescriptorPropertiesKHR32;
4480
4481 typedef struct VkPhysicalDeviceDriverProperties32
4482 {
4483     VkStructureType sType;
4484     void *pNext;
4485     VkDriverId driverID;
4486     char driverName[VK_MAX_DRIVER_NAME_SIZE];
4487     char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
4488     VkConformanceVersion conformanceVersion;
4489 } VkPhysicalDeviceDriverProperties32;
4490 typedef VkPhysicalDeviceDriverProperties32 VkPhysicalDeviceDriverPropertiesKHR32;
4491
4492 typedef struct VkPhysicalDeviceIDProperties32
4493 {
4494     VkStructureType sType;
4495     void *pNext;
4496     uint8_t deviceUUID[VK_UUID_SIZE];
4497     uint8_t driverUUID[VK_UUID_SIZE];
4498     uint8_t deviceLUID[VK_LUID_SIZE];
4499     uint32_t deviceNodeMask;
4500     VkBool32 deviceLUIDValid;
4501 } VkPhysicalDeviceIDProperties32;
4502 typedef VkPhysicalDeviceIDProperties32 VkPhysicalDeviceIDPropertiesKHR32;
4503
4504 typedef struct VkPhysicalDeviceMultiviewProperties32
4505 {
4506     VkStructureType sType;
4507     void *pNext;
4508     uint32_t maxMultiviewViewCount;
4509     uint32_t maxMultiviewInstanceIndex;
4510 } VkPhysicalDeviceMultiviewProperties32;
4511 typedef VkPhysicalDeviceMultiviewProperties32 VkPhysicalDeviceMultiviewPropertiesKHR32;
4512
4513 typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT32
4514 {
4515     VkStructureType sType;
4516     void *pNext;
4517     uint32_t maxDiscardRectangles;
4518 } VkPhysicalDeviceDiscardRectanglePropertiesEXT32;
4519
4520 typedef struct VkPhysicalDeviceSubgroupProperties32
4521 {
4522     VkStructureType sType;
4523     void *pNext;
4524     uint32_t subgroupSize;
4525     VkShaderStageFlags supportedStages;
4526     VkSubgroupFeatureFlags supportedOperations;
4527     VkBool32 quadOperationsInAllStages;
4528 } VkPhysicalDeviceSubgroupProperties32;
4529
4530 typedef struct VkPhysicalDevicePointClippingProperties32
4531 {
4532     VkStructureType sType;
4533     void *pNext;
4534     VkPointClippingBehavior pointClippingBehavior;
4535 } VkPhysicalDevicePointClippingProperties32;
4536 typedef VkPhysicalDevicePointClippingProperties32 VkPhysicalDevicePointClippingPropertiesKHR32;
4537
4538 typedef struct VkPhysicalDeviceProtectedMemoryProperties32
4539 {
4540     VkStructureType sType;
4541     void *pNext;
4542     VkBool32 protectedNoFault;
4543 } VkPhysicalDeviceProtectedMemoryProperties32;
4544
4545 typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties32
4546 {
4547     VkStructureType sType;
4548     void *pNext;
4549     VkBool32 filterMinmaxSingleComponentFormats;
4550     VkBool32 filterMinmaxImageComponentMapping;
4551 } VkPhysicalDeviceSamplerFilterMinmaxProperties32;
4552 typedef VkPhysicalDeviceSamplerFilterMinmaxProperties32 VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT32;
4553
4554 typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT32
4555 {
4556     VkStructureType sType;
4557     void *pNext;
4558     VkSampleCountFlags sampleLocationSampleCounts;
4559     VkExtent2D maxSampleLocationGridSize;
4560     float sampleLocationCoordinateRange[2];
4561     uint32_t sampleLocationSubPixelBits;
4562     VkBool32 variableSampleLocations;
4563 } VkPhysicalDeviceSampleLocationsPropertiesEXT32;
4564
4565 typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32
4566 {
4567     VkStructureType sType;
4568     void *pNext;
4569     uint32_t advancedBlendMaxColorAttachments;
4570     VkBool32 advancedBlendIndependentBlend;
4571     VkBool32 advancedBlendNonPremultipliedSrcColor;
4572     VkBool32 advancedBlendNonPremultipliedDstColor;
4573     VkBool32 advancedBlendCorrelatedOverlap;
4574     VkBool32 advancedBlendAllOperations;
4575 } VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32;
4576
4577 typedef struct VkPhysicalDeviceInlineUniformBlockProperties32
4578 {
4579     VkStructureType sType;
4580     void *pNext;
4581     uint32_t maxInlineUniformBlockSize;
4582     uint32_t maxPerStageDescriptorInlineUniformBlocks;
4583     uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
4584     uint32_t maxDescriptorSetInlineUniformBlocks;
4585     uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
4586 } VkPhysicalDeviceInlineUniformBlockProperties32;
4587 typedef VkPhysicalDeviceInlineUniformBlockProperties32 VkPhysicalDeviceInlineUniformBlockPropertiesEXT32;
4588
4589 typedef struct VkPhysicalDeviceMaintenance3Properties32
4590 {
4591     VkStructureType sType;
4592     void *pNext;
4593     uint32_t maxPerSetDescriptors;
4594     VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize;
4595 } VkPhysicalDeviceMaintenance3Properties32;
4596 typedef VkPhysicalDeviceMaintenance3Properties32 VkPhysicalDeviceMaintenance3PropertiesKHR32;
4597
4598 typedef struct VkPhysicalDeviceMaintenance4Properties32
4599 {
4600     VkStructureType sType;
4601     void *pNext;
4602     VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize;
4603 } VkPhysicalDeviceMaintenance4Properties32;
4604 typedef VkPhysicalDeviceMaintenance4Properties32 VkPhysicalDeviceMaintenance4PropertiesKHR32;
4605
4606 typedef struct VkPhysicalDeviceFloatControlsProperties32
4607 {
4608     VkStructureType sType;
4609     void *pNext;
4610     VkShaderFloatControlsIndependence denormBehaviorIndependence;
4611     VkShaderFloatControlsIndependence roundingModeIndependence;
4612     VkBool32 shaderSignedZeroInfNanPreserveFloat16;
4613     VkBool32 shaderSignedZeroInfNanPreserveFloat32;
4614     VkBool32 shaderSignedZeroInfNanPreserveFloat64;
4615     VkBool32 shaderDenormPreserveFloat16;
4616     VkBool32 shaderDenormPreserveFloat32;
4617     VkBool32 shaderDenormPreserveFloat64;
4618     VkBool32 shaderDenormFlushToZeroFloat16;
4619     VkBool32 shaderDenormFlushToZeroFloat32;
4620     VkBool32 shaderDenormFlushToZeroFloat64;
4621     VkBool32 shaderRoundingModeRTEFloat16;
4622     VkBool32 shaderRoundingModeRTEFloat32;
4623     VkBool32 shaderRoundingModeRTEFloat64;
4624     VkBool32 shaderRoundingModeRTZFloat16;
4625     VkBool32 shaderRoundingModeRTZFloat32;
4626     VkBool32 shaderRoundingModeRTZFloat64;
4627 } VkPhysicalDeviceFloatControlsProperties32;
4628 typedef VkPhysicalDeviceFloatControlsProperties32 VkPhysicalDeviceFloatControlsPropertiesKHR32;
4629
4630 typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT32
4631 {
4632     VkStructureType sType;
4633     void *pNext;
4634     VkDeviceSize DECLSPEC_ALIGN(8) minImportedHostPointerAlignment;
4635 } VkPhysicalDeviceExternalMemoryHostPropertiesEXT32;
4636
4637 typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT32
4638 {
4639     VkStructureType sType;
4640     void *pNext;
4641     float primitiveOverestimationSize;
4642     float maxExtraPrimitiveOverestimationSize;
4643     float extraPrimitiveOverestimationSizeGranularity;
4644     VkBool32 primitiveUnderestimation;
4645     VkBool32 conservativePointAndLineRasterization;
4646     VkBool32 degenerateTrianglesRasterized;
4647     VkBool32 degenerateLinesRasterized;
4648     VkBool32 fullyCoveredFragmentShaderInputVariable;
4649     VkBool32 conservativeRasterizationPostDepthCoverage;
4650 } VkPhysicalDeviceConservativeRasterizationPropertiesEXT32;
4651
4652 typedef struct VkPhysicalDeviceShaderCorePropertiesAMD32
4653 {
4654     VkStructureType sType;
4655     void *pNext;
4656     uint32_t shaderEngineCount;
4657     uint32_t shaderArraysPerEngineCount;
4658     uint32_t computeUnitsPerShaderArray;
4659     uint32_t simdPerComputeUnit;
4660     uint32_t wavefrontsPerSimd;
4661     uint32_t wavefrontSize;
4662     uint32_t sgprsPerSimd;
4663     uint32_t minSgprAllocation;
4664     uint32_t maxSgprAllocation;
4665     uint32_t sgprAllocationGranularity;
4666     uint32_t vgprsPerSimd;
4667     uint32_t minVgprAllocation;
4668     uint32_t maxVgprAllocation;
4669     uint32_t vgprAllocationGranularity;
4670 } VkPhysicalDeviceShaderCorePropertiesAMD32;
4671
4672 typedef struct VkPhysicalDeviceShaderCoreProperties2AMD32
4673 {
4674     VkStructureType sType;
4675     void *pNext;
4676     VkShaderCorePropertiesFlagsAMD shaderCoreFeatures;
4677     uint32_t activeComputeUnitCount;
4678 } VkPhysicalDeviceShaderCoreProperties2AMD32;
4679
4680 typedef struct VkPhysicalDeviceDescriptorIndexingProperties32
4681 {
4682     VkStructureType sType;
4683     void *pNext;
4684     uint32_t maxUpdateAfterBindDescriptorsInAllPools;
4685     VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
4686     VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
4687     VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
4688     VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
4689     VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
4690     VkBool32 robustBufferAccessUpdateAfterBind;
4691     VkBool32 quadDivergentImplicitLod;
4692     uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
4693     uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
4694     uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
4695     uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
4696     uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
4697     uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
4698     uint32_t maxPerStageUpdateAfterBindResources;
4699     uint32_t maxDescriptorSetUpdateAfterBindSamplers;
4700     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
4701     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
4702     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
4703     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
4704     uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
4705     uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
4706     uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
4707 } VkPhysicalDeviceDescriptorIndexingProperties32;
4708 typedef VkPhysicalDeviceDescriptorIndexingProperties32 VkPhysicalDeviceDescriptorIndexingPropertiesEXT32;
4709
4710 typedef struct VkPhysicalDeviceTimelineSemaphoreProperties32
4711 {
4712     VkStructureType sType;
4713     void *pNext;
4714     uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference;
4715 } VkPhysicalDeviceTimelineSemaphoreProperties32;
4716 typedef VkPhysicalDeviceTimelineSemaphoreProperties32 VkPhysicalDeviceTimelineSemaphorePropertiesKHR32;
4717
4718 typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32
4719 {
4720     VkStructureType sType;
4721     void *pNext;
4722     uint32_t maxVertexAttribDivisor;
4723 } VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32;
4724
4725 typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT32
4726 {
4727     VkStructureType sType;
4728     void *pNext;
4729     uint32_t pciDomain;
4730     uint32_t pciBus;
4731     uint32_t pciDevice;
4732     uint32_t pciFunction;
4733 } VkPhysicalDevicePCIBusInfoPropertiesEXT32;
4734
4735 typedef struct VkPhysicalDeviceDepthStencilResolveProperties32
4736 {
4737     VkStructureType sType;
4738     void *pNext;
4739     VkResolveModeFlags supportedDepthResolveModes;
4740     VkResolveModeFlags supportedStencilResolveModes;
4741     VkBool32 independentResolveNone;
4742     VkBool32 independentResolve;
4743 } VkPhysicalDeviceDepthStencilResolveProperties32;
4744 typedef VkPhysicalDeviceDepthStencilResolveProperties32 VkPhysicalDeviceDepthStencilResolvePropertiesKHR32;
4745
4746 typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT32
4747 {
4748     VkStructureType sType;
4749     void *pNext;
4750     uint32_t maxTransformFeedbackStreams;
4751     uint32_t maxTransformFeedbackBuffers;
4752     VkDeviceSize DECLSPEC_ALIGN(8) maxTransformFeedbackBufferSize;
4753     uint32_t maxTransformFeedbackStreamDataSize;
4754     uint32_t maxTransformFeedbackBufferDataSize;
4755     uint32_t maxTransformFeedbackBufferDataStride;
4756     VkBool32 transformFeedbackQueries;
4757     VkBool32 transformFeedbackStreamsLinesTriangles;
4758     VkBool32 transformFeedbackRasterizationStreamSelect;
4759     VkBool32 transformFeedbackDraw;
4760 } VkPhysicalDeviceTransformFeedbackPropertiesEXT32;
4761
4762 typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32
4763 {
4764     VkStructureType sType;
4765     void *pNext;
4766     VkQueueFlags supportedQueues;
4767 } VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32;
4768
4769 typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesNV32
4770 {
4771     VkStructureType sType;
4772     void *pNext;
4773     VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethods;
4774     uint64_t DECLSPEC_ALIGN(8) maxDecompressionIndirectCount;
4775 } VkPhysicalDeviceMemoryDecompressionPropertiesNV32;
4776
4777 typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV32
4778 {
4779     VkStructureType sType;
4780     void *pNext;
4781     VkExtent2D shadingRateTexelSize;
4782     uint32_t shadingRatePaletteSize;
4783     uint32_t shadingRateMaxCoarseSamples;
4784 } VkPhysicalDeviceShadingRateImagePropertiesNV32;
4785
4786 typedef struct VkPhysicalDeviceMeshShaderPropertiesNV32
4787 {
4788     VkStructureType sType;
4789     void *pNext;
4790     uint32_t maxDrawMeshTasksCount;
4791     uint32_t maxTaskWorkGroupInvocations;
4792     uint32_t maxTaskWorkGroupSize[3];
4793     uint32_t maxTaskTotalMemorySize;
4794     uint32_t maxTaskOutputCount;
4795     uint32_t maxMeshWorkGroupInvocations;
4796     uint32_t maxMeshWorkGroupSize[3];
4797     uint32_t maxMeshTotalMemorySize;
4798     uint32_t maxMeshOutputVertices;
4799     uint32_t maxMeshOutputPrimitives;
4800     uint32_t maxMeshMultiviewViewCount;
4801     uint32_t meshOutputPerVertexGranularity;
4802     uint32_t meshOutputPerPrimitiveGranularity;
4803 } VkPhysicalDeviceMeshShaderPropertiesNV32;
4804
4805 typedef struct VkPhysicalDeviceMeshShaderPropertiesEXT32
4806 {
4807     VkStructureType sType;
4808     void *pNext;
4809     uint32_t maxTaskWorkGroupTotalCount;
4810     uint32_t maxTaskWorkGroupCount[3];
4811     uint32_t maxTaskWorkGroupInvocations;
4812     uint32_t maxTaskWorkGroupSize[3];
4813     uint32_t maxTaskPayloadSize;
4814     uint32_t maxTaskSharedMemorySize;
4815     uint32_t maxTaskPayloadAndSharedMemorySize;
4816     uint32_t maxMeshWorkGroupTotalCount;
4817     uint32_t maxMeshWorkGroupCount[3];
4818     uint32_t maxMeshWorkGroupInvocations;
4819     uint32_t maxMeshWorkGroupSize[3];
4820     uint32_t maxMeshSharedMemorySize;
4821     uint32_t maxMeshPayloadAndSharedMemorySize;
4822     uint32_t maxMeshOutputMemorySize;
4823     uint32_t maxMeshPayloadAndOutputMemorySize;
4824     uint32_t maxMeshOutputComponents;
4825     uint32_t maxMeshOutputVertices;
4826     uint32_t maxMeshOutputPrimitives;
4827     uint32_t maxMeshOutputLayers;
4828     uint32_t maxMeshMultiviewViewCount;
4829     uint32_t meshOutputPerVertexGranularity;
4830     uint32_t meshOutputPerPrimitiveGranularity;
4831     uint32_t maxPreferredTaskWorkGroupInvocations;
4832     uint32_t maxPreferredMeshWorkGroupInvocations;
4833     VkBool32 prefersLocalInvocationVertexOutput;
4834     VkBool32 prefersLocalInvocationPrimitiveOutput;
4835     VkBool32 prefersCompactVertexOutput;
4836     VkBool32 prefersCompactPrimitiveOutput;
4837 } VkPhysicalDeviceMeshShaderPropertiesEXT32;
4838
4839 typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR32
4840 {
4841     VkStructureType sType;
4842     void *pNext;
4843     uint64_t DECLSPEC_ALIGN(8) maxGeometryCount;
4844     uint64_t DECLSPEC_ALIGN(8) maxInstanceCount;
4845     uint64_t DECLSPEC_ALIGN(8) maxPrimitiveCount;
4846     uint32_t maxPerStageDescriptorAccelerationStructures;
4847     uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
4848     uint32_t maxDescriptorSetAccelerationStructures;
4849     uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures;
4850     uint32_t minAccelerationStructureScratchOffsetAlignment;
4851 } VkPhysicalDeviceAccelerationStructurePropertiesKHR32;
4852
4853 typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR32
4854 {
4855     VkStructureType sType;
4856     void *pNext;
4857     uint32_t shaderGroupHandleSize;
4858     uint32_t maxRayRecursionDepth;
4859     uint32_t maxShaderGroupStride;
4860     uint32_t shaderGroupBaseAlignment;
4861     uint32_t shaderGroupHandleCaptureReplaySize;
4862     uint32_t maxRayDispatchInvocationCount;
4863     uint32_t shaderGroupHandleAlignment;
4864     uint32_t maxRayHitAttributeSize;
4865 } VkPhysicalDeviceRayTracingPipelinePropertiesKHR32;
4866
4867 typedef struct VkPhysicalDeviceRayTracingPropertiesNV32
4868 {
4869     VkStructureType sType;
4870     void *pNext;
4871     uint32_t shaderGroupHandleSize;
4872     uint32_t maxRecursionDepth;
4873     uint32_t maxShaderGroupStride;
4874     uint32_t shaderGroupBaseAlignment;
4875     uint64_t DECLSPEC_ALIGN(8) maxGeometryCount;
4876     uint64_t DECLSPEC_ALIGN(8) maxInstanceCount;
4877     uint64_t DECLSPEC_ALIGN(8) maxTriangleCount;
4878     uint32_t maxDescriptorSetAccelerationStructures;
4879 } VkPhysicalDeviceRayTracingPropertiesNV32;
4880
4881 typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT32
4882 {
4883     VkStructureType sType;
4884     void *pNext;
4885     VkExtent2D minFragmentDensityTexelSize;
4886     VkExtent2D maxFragmentDensityTexelSize;
4887     VkBool32 fragmentDensityInvocations;
4888 } VkPhysicalDeviceFragmentDensityMapPropertiesEXT32;
4889
4890 typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32
4891 {
4892     VkStructureType sType;
4893     void *pNext;
4894     VkBool32 subsampledLoads;
4895     VkBool32 subsampledCoarseReconstructionEarlyAccess;
4896     uint32_t maxSubsampledArrayLayers;
4897     uint32_t maxDescriptorSetSubsampledSamplers;
4898 } VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32;
4899
4900 typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32
4901 {
4902     VkStructureType sType;
4903     void *pNext;
4904     VkExtent2D fragmentDensityOffsetGranularity;
4905 } VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32;
4906
4907 typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV32
4908 {
4909     VkStructureType sType;
4910     void *pNext;
4911     VkShaderStageFlags cooperativeMatrixSupportedStages;
4912 } VkPhysicalDeviceCooperativeMatrixPropertiesNV32;
4913
4914 typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR32
4915 {
4916     VkStructureType sType;
4917     void *pNext;
4918     VkBool32 allowCommandBufferQueryCopies;
4919 } VkPhysicalDevicePerformanceQueryPropertiesKHR32;
4920
4921 typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32
4922 {
4923     VkStructureType sType;
4924     void *pNext;
4925     uint32_t shaderSMCount;
4926     uint32_t shaderWarpsPerSM;
4927 } VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32;
4928
4929 typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties32
4930 {
4931     VkStructureType sType;
4932     void *pNext;
4933     VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes;
4934     VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
4935     VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes;
4936     VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
4937 } VkPhysicalDeviceTexelBufferAlignmentProperties32;
4938 typedef VkPhysicalDeviceTexelBufferAlignmentProperties32 VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT32;
4939
4940 typedef struct VkPhysicalDeviceSubgroupSizeControlProperties32
4941 {
4942     VkStructureType sType;
4943     void *pNext;
4944     uint32_t minSubgroupSize;
4945     uint32_t maxSubgroupSize;
4946     uint32_t maxComputeWorkgroupSubgroups;
4947     VkShaderStageFlags requiredSubgroupSizeStages;
4948 } VkPhysicalDeviceSubgroupSizeControlProperties32;
4949 typedef VkPhysicalDeviceSubgroupSizeControlProperties32 VkPhysicalDeviceSubgroupSizeControlPropertiesEXT32;
4950
4951 typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32
4952 {
4953     VkStructureType sType;
4954     void *pNext;
4955     uint32_t maxSubpassShadingWorkgroupSizeAspectRatio;
4956 } VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32;
4957
4958 typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT32
4959 {
4960     VkStructureType sType;
4961     void *pNext;
4962     uint32_t lineSubPixelPrecisionBits;
4963 } VkPhysicalDeviceLineRasterizationPropertiesEXT32;
4964
4965 typedef struct VkPhysicalDeviceVulkan11Properties32
4966 {
4967     VkStructureType sType;
4968     void *pNext;
4969     uint8_t deviceUUID[VK_UUID_SIZE];
4970     uint8_t driverUUID[VK_UUID_SIZE];
4971     uint8_t deviceLUID[VK_LUID_SIZE];
4972     uint32_t deviceNodeMask;
4973     VkBool32 deviceLUIDValid;
4974     uint32_t subgroupSize;
4975     VkShaderStageFlags subgroupSupportedStages;
4976     VkSubgroupFeatureFlags subgroupSupportedOperations;
4977     VkBool32 subgroupQuadOperationsInAllStages;
4978     VkPointClippingBehavior pointClippingBehavior;
4979     uint32_t maxMultiviewViewCount;
4980     uint32_t maxMultiviewInstanceIndex;
4981     VkBool32 protectedNoFault;
4982     uint32_t maxPerSetDescriptors;
4983     VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize;
4984 } VkPhysicalDeviceVulkan11Properties32;
4985
4986 typedef struct VkPhysicalDeviceVulkan12Properties32
4987 {
4988     VkStructureType sType;
4989     void *pNext;
4990     VkDriverId driverID;
4991     char driverName[VK_MAX_DRIVER_NAME_SIZE];
4992     char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
4993     VkConformanceVersion conformanceVersion;
4994     VkShaderFloatControlsIndependence denormBehaviorIndependence;
4995     VkShaderFloatControlsIndependence roundingModeIndependence;
4996     VkBool32 shaderSignedZeroInfNanPreserveFloat16;
4997     VkBool32 shaderSignedZeroInfNanPreserveFloat32;
4998     VkBool32 shaderSignedZeroInfNanPreserveFloat64;
4999     VkBool32 shaderDenormPreserveFloat16;
5000     VkBool32 shaderDenormPreserveFloat32;
5001     VkBool32 shaderDenormPreserveFloat64;
5002     VkBool32 shaderDenormFlushToZeroFloat16;
5003     VkBool32 shaderDenormFlushToZeroFloat32;
5004     VkBool32 shaderDenormFlushToZeroFloat64;
5005     VkBool32 shaderRoundingModeRTEFloat16;
5006     VkBool32 shaderRoundingModeRTEFloat32;
5007     VkBool32 shaderRoundingModeRTEFloat64;
5008     VkBool32 shaderRoundingModeRTZFloat16;
5009     VkBool32 shaderRoundingModeRTZFloat32;
5010     VkBool32 shaderRoundingModeRTZFloat64;
5011     uint32_t maxUpdateAfterBindDescriptorsInAllPools;
5012     VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
5013     VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
5014     VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
5015     VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
5016     VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
5017     VkBool32 robustBufferAccessUpdateAfterBind;
5018     VkBool32 quadDivergentImplicitLod;
5019     uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
5020     uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
5021     uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
5022     uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
5023     uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
5024     uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
5025     uint32_t maxPerStageUpdateAfterBindResources;
5026     uint32_t maxDescriptorSetUpdateAfterBindSamplers;
5027     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
5028     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
5029     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
5030     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
5031     uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
5032     uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
5033     uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
5034     VkResolveModeFlags supportedDepthResolveModes;
5035     VkResolveModeFlags supportedStencilResolveModes;
5036     VkBool32 independentResolveNone;
5037     VkBool32 independentResolve;
5038     VkBool32 filterMinmaxSingleComponentFormats;
5039     VkBool32 filterMinmaxImageComponentMapping;
5040     uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference;
5041     VkSampleCountFlags framebufferIntegerColorSampleCounts;
5042 } VkPhysicalDeviceVulkan12Properties32;
5043
5044 typedef struct VkPhysicalDeviceVulkan13Properties32
5045 {
5046     VkStructureType sType;
5047     void *pNext;
5048     uint32_t minSubgroupSize;
5049     uint32_t maxSubgroupSize;
5050     uint32_t maxComputeWorkgroupSubgroups;
5051     VkShaderStageFlags requiredSubgroupSizeStages;
5052     uint32_t maxInlineUniformBlockSize;
5053     uint32_t maxPerStageDescriptorInlineUniformBlocks;
5054     uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
5055     uint32_t maxDescriptorSetInlineUniformBlocks;
5056     uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
5057     uint32_t maxInlineUniformTotalSize;
5058     VkBool32 integerDotProduct8BitUnsignedAccelerated;
5059     VkBool32 integerDotProduct8BitSignedAccelerated;
5060     VkBool32 integerDotProduct8BitMixedSignednessAccelerated;
5061     VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;
5062     VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;
5063     VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;
5064     VkBool32 integerDotProduct16BitUnsignedAccelerated;
5065     VkBool32 integerDotProduct16BitSignedAccelerated;
5066     VkBool32 integerDotProduct16BitMixedSignednessAccelerated;
5067     VkBool32 integerDotProduct32BitUnsignedAccelerated;
5068     VkBool32 integerDotProduct32BitSignedAccelerated;
5069     VkBool32 integerDotProduct32BitMixedSignednessAccelerated;
5070     VkBool32 integerDotProduct64BitUnsignedAccelerated;
5071     VkBool32 integerDotProduct64BitSignedAccelerated;
5072     VkBool32 integerDotProduct64BitMixedSignednessAccelerated;
5073     VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
5074     VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;
5075     VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
5076     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
5077     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
5078     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
5079     VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
5080     VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;
5081     VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
5082     VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
5083     VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;
5084     VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
5085     VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
5086     VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;
5087     VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
5088     VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes;
5089     VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
5090     VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes;
5091     VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
5092     VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize;
5093 } VkPhysicalDeviceVulkan13Properties32;
5094
5095 typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT32
5096 {
5097     VkStructureType sType;
5098     void *pNext;
5099     uint32_t maxCustomBorderColorSamplers;
5100 } VkPhysicalDeviceCustomBorderColorPropertiesEXT32;
5101
5102 typedef struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32
5103 {
5104     VkStructureType sType;
5105     void *pNext;
5106     VkBool32 dynamicPrimitiveTopologyUnrestricted;
5107 } VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32;
5108
5109 typedef struct VkPhysicalDeviceRobustness2PropertiesEXT32
5110 {
5111     VkStructureType sType;
5112     void *pNext;
5113     VkDeviceSize DECLSPEC_ALIGN(8) robustStorageBufferAccessSizeAlignment;
5114     VkDeviceSize DECLSPEC_ALIGN(8) robustUniformBufferAccessSizeAlignment;
5115 } VkPhysicalDeviceRobustness2PropertiesEXT32;
5116
5117 typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR32
5118 {
5119     VkStructureType sType;
5120     void *pNext;
5121     VkExtent2D minFragmentShadingRateAttachmentTexelSize;
5122     VkExtent2D maxFragmentShadingRateAttachmentTexelSize;
5123     uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
5124     VkBool32 primitiveFragmentShadingRateWithMultipleViewports;
5125     VkBool32 layeredShadingRateAttachments;
5126     VkBool32 fragmentShadingRateNonTrivialCombinerOps;
5127     VkExtent2D maxFragmentSize;
5128     uint32_t maxFragmentSizeAspectRatio;
5129     uint32_t maxFragmentShadingRateCoverageSamples;
5130     VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples;
5131     VkBool32 fragmentShadingRateWithShaderDepthStencilWrites;
5132     VkBool32 fragmentShadingRateWithSampleMask;
5133     VkBool32 fragmentShadingRateWithShaderSampleMask;
5134     VkBool32 fragmentShadingRateWithConservativeRasterization;
5135     VkBool32 fragmentShadingRateWithFragmentShaderInterlock;
5136     VkBool32 fragmentShadingRateWithCustomSampleLocations;
5137     VkBool32 fragmentShadingRateStrictMultiplyCombiner;
5138 } VkPhysicalDeviceFragmentShadingRatePropertiesKHR32;
5139
5140 typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32
5141 {
5142     VkStructureType sType;
5143     void *pNext;
5144     VkSampleCountFlagBits maxFragmentShadingRateInvocationCount;
5145 } VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32;
5146
5147 typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT32
5148 {
5149     VkStructureType sType;
5150     void *pNext;
5151     VkBool32 provokingVertexModePerPipeline;
5152     VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex;
5153 } VkPhysicalDeviceProvokingVertexPropertiesEXT32;
5154
5155 typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties32
5156 {
5157     VkStructureType sType;
5158     void *pNext;
5159     VkBool32 integerDotProduct8BitUnsignedAccelerated;
5160     VkBool32 integerDotProduct8BitSignedAccelerated;
5161     VkBool32 integerDotProduct8BitMixedSignednessAccelerated;
5162     VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;
5163     VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;
5164     VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;
5165     VkBool32 integerDotProduct16BitUnsignedAccelerated;
5166     VkBool32 integerDotProduct16BitSignedAccelerated;
5167     VkBool32 integerDotProduct16BitMixedSignednessAccelerated;
5168     VkBool32 integerDotProduct32BitUnsignedAccelerated;
5169     VkBool32 integerDotProduct32BitSignedAccelerated;
5170     VkBool32 integerDotProduct32BitMixedSignednessAccelerated;
5171     VkBool32 integerDotProduct64BitUnsignedAccelerated;
5172     VkBool32 integerDotProduct64BitSignedAccelerated;
5173     VkBool32 integerDotProduct64BitMixedSignednessAccelerated;
5174     VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
5175     VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;
5176     VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
5177     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
5178     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
5179     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
5180     VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
5181     VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;
5182     VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
5183     VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
5184     VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;
5185     VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
5186     VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
5187     VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;
5188     VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
5189 } VkPhysicalDeviceShaderIntegerDotProductProperties32;
5190 typedef VkPhysicalDeviceShaderIntegerDotProductProperties32 VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR32;
5191
5192 typedef struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32
5193 {
5194     VkStructureType sType;
5195     void *pNext;
5196     VkBool32 triStripVertexOrderIndependentOfProvokingVertex;
5197 } VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32;
5198
5199 typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32
5200 {
5201     VkStructureType sType;
5202     void *pNext;
5203     VkBool32 graphicsPipelineLibraryFastLinking;
5204     VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration;
5205 } VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32;
5206
5207 typedef struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32
5208 {
5209     VkStructureType sType;
5210     void *pNext;
5211     uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE];
5212 } VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32;
5213
5214 typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT32
5215 {
5216     VkStructureType sType;
5217     void *pNext;
5218     uint32_t maxOpacity2StateSubdivisionLevel;
5219     uint32_t maxOpacity4StateSubdivisionLevel;
5220 } VkPhysicalDeviceOpacityMicromapPropertiesEXT32;
5221
5222 typedef struct VkPhysicalDevicePipelineRobustnessPropertiesEXT32
5223 {
5224     VkStructureType sType;
5225     void *pNext;
5226     VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessStorageBuffers;
5227     VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessUniformBuffers;
5228     VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessVertexInputs;
5229     VkPipelineRobustnessImageBehaviorEXT defaultRobustnessImages;
5230 } VkPhysicalDevicePipelineRobustnessPropertiesEXT32;
5231
5232 typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM32
5233 {
5234     VkStructureType sType;
5235     void *pNext;
5236     uint32_t maxWeightFilterPhases;
5237     VkExtent2D maxWeightFilterDimension;
5238     VkExtent2D maxBlockMatchRegion;
5239     VkExtent2D maxBoxFilterBlockSize;
5240 } VkPhysicalDeviceImageProcessingPropertiesQCOM32;
5241
5242 typedef struct VkPhysicalDeviceOpticalFlowPropertiesNV32
5243 {
5244     VkStructureType sType;
5245     void *pNext;
5246     VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes;
5247     VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes;
5248     VkBool32 hintSupported;
5249     VkBool32 costSupported;
5250     VkBool32 bidirectionalFlowSupported;
5251     VkBool32 globalFlowSupported;
5252     uint32_t minWidth;
5253     uint32_t minHeight;
5254     uint32_t maxWidth;
5255     uint32_t maxHeight;
5256     uint32_t maxNumRegionsOfInterest;
5257 } VkPhysicalDeviceOpticalFlowPropertiesNV32;
5258
5259 typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32
5260 {
5261     VkStructureType sType;
5262     void *pNext;
5263     uint64_t DECLSPEC_ALIGN(8) shaderCoreMask;
5264     uint32_t shaderCoreCount;
5265     uint32_t shaderWarpsPerCore;
5266 } VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32;
5267
5268 typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32
5269 {
5270     VkStructureType sType;
5271     void *pNext;
5272     VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint;
5273 } VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32;
5274
5275 typedef struct VkPhysicalDeviceProperties232
5276 {
5277     VkStructureType sType;
5278     void *pNext;
5279     VkPhysicalDeviceProperties32 DECLSPEC_ALIGN(8) properties;
5280 } VkPhysicalDeviceProperties232;
5281 typedef VkPhysicalDeviceProperties232 VkPhysicalDeviceProperties2KHR32;
5282
5283 typedef struct VkQueueFamilyGlobalPriorityPropertiesKHR32
5284 {
5285     VkStructureType sType;
5286     void *pNext;
5287     uint32_t priorityCount;
5288     VkQueueGlobalPriorityKHR priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_KHR];
5289 } VkQueueFamilyGlobalPriorityPropertiesKHR32;
5290 typedef VkQueueFamilyGlobalPriorityPropertiesKHR32 VkQueueFamilyGlobalPriorityPropertiesEXT32;
5291
5292 typedef struct VkQueueFamilyCheckpointPropertiesNV32
5293 {
5294     VkStructureType sType;
5295     void *pNext;
5296     VkPipelineStageFlags checkpointExecutionStageMask;
5297 } VkQueueFamilyCheckpointPropertiesNV32;
5298
5299 typedef struct VkQueueFamilyCheckpointProperties2NV32
5300 {
5301     VkStructureType sType;
5302     void *pNext;
5303     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) checkpointExecutionStageMask;
5304 } VkQueueFamilyCheckpointProperties2NV32;
5305
5306 typedef struct VkQueueFamilyProperties232
5307 {
5308     VkStructureType sType;
5309     void *pNext;
5310     VkQueueFamilyProperties queueFamilyProperties;
5311 } VkQueueFamilyProperties232;
5312 typedef VkQueueFamilyProperties232 VkQueueFamilyProperties2KHR32;
5313
5314 typedef struct VkPhysicalDeviceSparseImageFormatInfo232
5315 {
5316     VkStructureType sType;
5317     const void *pNext;
5318     VkFormat format;
5319     VkImageType type;
5320     VkSampleCountFlagBits samples;
5321     VkImageUsageFlags usage;
5322     VkImageTiling tiling;
5323 } VkPhysicalDeviceSparseImageFormatInfo232;
5324 typedef VkPhysicalDeviceSparseImageFormatInfo232 VkPhysicalDeviceSparseImageFormatInfo2KHR32;
5325
5326 typedef struct VkSparseImageFormatProperties232
5327 {
5328     VkStructureType sType;
5329     void *pNext;
5330     VkSparseImageFormatProperties properties;
5331 } VkSparseImageFormatProperties232;
5332 typedef VkSparseImageFormatProperties232 VkSparseImageFormatProperties2KHR32;
5333
5334 typedef struct VkFramebufferMixedSamplesCombinationNV32
5335 {
5336     VkStructureType sType;
5337     void *pNext;
5338     VkCoverageReductionModeNV coverageReductionMode;
5339     VkSampleCountFlagBits rasterizationSamples;
5340     VkSampleCountFlags depthStencilSamples;
5341     VkSampleCountFlags colorSamples;
5342 } VkFramebufferMixedSamplesCombinationNV32;
5343
5344 typedef struct VkPhysicalDeviceSurfaceInfo2KHR32
5345 {
5346     VkStructureType sType;
5347     const void *pNext;
5348     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
5349 } VkPhysicalDeviceSurfaceInfo2KHR32;
5350
5351 typedef struct VkSurfaceCapabilitiesPresentBarrierNV32
5352 {
5353     VkStructureType sType;
5354     void *pNext;
5355     VkBool32 presentBarrierSupported;
5356 } VkSurfaceCapabilitiesPresentBarrierNV32;
5357
5358 typedef struct VkSurfaceCapabilities2KHR32
5359 {
5360     VkStructureType sType;
5361     void *pNext;
5362     VkSurfaceCapabilitiesKHR surfaceCapabilities;
5363 } VkSurfaceCapabilities2KHR32;
5364
5365 typedef struct VkSurfaceFormat2KHR32
5366 {
5367     VkStructureType sType;
5368     void *pNext;
5369     VkSurfaceFormatKHR surfaceFormat;
5370 } VkSurfaceFormat2KHR32;
5371
5372 typedef struct VkPhysicalDeviceToolProperties32
5373 {
5374     VkStructureType sType;
5375     void *pNext;
5376     char name[VK_MAX_EXTENSION_NAME_SIZE];
5377     char version[VK_MAX_EXTENSION_NAME_SIZE];
5378     VkToolPurposeFlags purposes;
5379     char description[VK_MAX_DESCRIPTION_SIZE];
5380     char layer[VK_MAX_EXTENSION_NAME_SIZE];
5381 } VkPhysicalDeviceToolProperties32;
5382 typedef VkPhysicalDeviceToolProperties32 VkPhysicalDeviceToolPropertiesEXT32;
5383
5384 typedef struct VkPipelineExecutableInfoKHR32
5385 {
5386     VkStructureType sType;
5387     const void *pNext;
5388     VkPipeline DECLSPEC_ALIGN(8) pipeline;
5389     uint32_t executableIndex;
5390 } VkPipelineExecutableInfoKHR32;
5391
5392 typedef struct VkPipelineExecutableInternalRepresentationKHR32
5393 {
5394     VkStructureType sType;
5395     void *pNext;
5396     char name[VK_MAX_DESCRIPTION_SIZE];
5397     char description[VK_MAX_DESCRIPTION_SIZE];
5398     VkBool32 isText;
5399     size_t dataSize;
5400     void *pData;
5401 } VkPipelineExecutableInternalRepresentationKHR32;
5402
5403 typedef struct VkPipelineInfoKHR32
5404 {
5405     VkStructureType sType;
5406     const void *pNext;
5407     VkPipeline DECLSPEC_ALIGN(8) pipeline;
5408 } VkPipelineInfoKHR32;
5409 typedef VkPipelineInfoKHR32 VkPipelineInfoEXT32;
5410
5411 typedef struct VkPipelineExecutablePropertiesKHR32
5412 {
5413     VkStructureType sType;
5414     void *pNext;
5415     VkShaderStageFlags stages;
5416     char name[VK_MAX_DESCRIPTION_SIZE];
5417     char description[VK_MAX_DESCRIPTION_SIZE];
5418     uint32_t subgroupSize;
5419 } VkPipelineExecutablePropertiesKHR32;
5420
5421 typedef struct VkPipelineExecutableStatisticKHR32
5422 {
5423     VkStructureType sType;
5424     void *pNext;
5425     char name[VK_MAX_DESCRIPTION_SIZE];
5426     char description[VK_MAX_DESCRIPTION_SIZE];
5427     VkPipelineExecutableStatisticFormatKHR format;
5428     VkPipelineExecutableStatisticValueKHR DECLSPEC_ALIGN(8) value;
5429 } VkPipelineExecutableStatisticKHR32;
5430
5431
5432 typedef struct VkCheckpointData2NV32
5433 {
5434     VkStructureType sType;
5435     void *pNext;
5436     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
5437     void *pCheckpointMarker;
5438 } VkCheckpointData2NV32;
5439
5440 typedef struct VkCheckpointDataNV32
5441 {
5442     VkStructureType sType;
5443     void *pNext;
5444     VkPipelineStageFlagBits stage;
5445     void *pCheckpointMarker;
5446 } VkCheckpointDataNV32;
5447
5448 typedef struct VkShaderModuleIdentifierEXT32
5449 {
5450     VkStructureType sType;
5451     void *pNext;
5452     uint32_t identifierSize;
5453     uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT];
5454 } VkShaderModuleIdentifierEXT32;
5455
5456 typedef struct VkInitializePerformanceApiInfoINTEL32
5457 {
5458     VkStructureType sType;
5459     const void *pNext;
5460     void *pUserData;
5461 } VkInitializePerformanceApiInfoINTEL32;
5462
5463 typedef struct VkSparseMemoryBind32
5464 {
5465     VkDeviceSize DECLSPEC_ALIGN(8) resourceOffset;
5466     VkDeviceSize DECLSPEC_ALIGN(8) size;
5467     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
5468     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
5469     VkSparseMemoryBindFlags flags;
5470 } VkSparseMemoryBind32;
5471
5472 typedef struct VkSparseBufferMemoryBindInfo32
5473 {
5474     VkBuffer DECLSPEC_ALIGN(8) buffer;
5475     uint32_t bindCount;
5476     const VkSparseMemoryBind32 *pBinds;
5477 } VkSparseBufferMemoryBindInfo32;
5478
5479 typedef struct VkSparseImageOpaqueMemoryBindInfo32
5480 {
5481     VkImage DECLSPEC_ALIGN(8) image;
5482     uint32_t bindCount;
5483     const VkSparseMemoryBind32 *pBinds;
5484 } VkSparseImageOpaqueMemoryBindInfo32;
5485
5486 typedef struct VkSparseImageMemoryBind32
5487 {
5488     VkImageSubresource subresource;
5489     VkOffset3D offset;
5490     VkExtent3D extent;
5491     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
5492     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
5493     VkSparseMemoryBindFlags flags;
5494 } VkSparseImageMemoryBind32;
5495
5496 typedef struct VkSparseImageMemoryBindInfo32
5497 {
5498     VkImage DECLSPEC_ALIGN(8) image;
5499     uint32_t bindCount;
5500     const VkSparseImageMemoryBind32 *pBinds;
5501 } VkSparseImageMemoryBindInfo32;
5502
5503 typedef struct VkDeviceGroupBindSparseInfo32
5504 {
5505     VkStructureType sType;
5506     const void *pNext;
5507     uint32_t resourceDeviceIndex;
5508     uint32_t memoryDeviceIndex;
5509 } VkDeviceGroupBindSparseInfo32;
5510 typedef VkDeviceGroupBindSparseInfo32 VkDeviceGroupBindSparseInfoKHR32;
5511
5512 typedef struct VkTimelineSemaphoreSubmitInfo32
5513 {
5514     VkStructureType sType;
5515     const void *pNext;
5516     uint32_t waitSemaphoreValueCount;
5517     const uint64_t *pWaitSemaphoreValues;
5518     uint32_t signalSemaphoreValueCount;
5519     const uint64_t *pSignalSemaphoreValues;
5520 } VkTimelineSemaphoreSubmitInfo32;
5521 typedef VkTimelineSemaphoreSubmitInfo32 VkTimelineSemaphoreSubmitInfoKHR32;
5522
5523 typedef struct VkBindSparseInfo32
5524 {
5525     VkStructureType sType;
5526     const void *pNext;
5527     uint32_t waitSemaphoreCount;
5528     const VkSemaphore *pWaitSemaphores;
5529     uint32_t bufferBindCount;
5530     const VkSparseBufferMemoryBindInfo32 *pBufferBinds;
5531     uint32_t imageOpaqueBindCount;
5532     const VkSparseImageOpaqueMemoryBindInfo32 *pImageOpaqueBinds;
5533     uint32_t imageBindCount;
5534     const VkSparseImageMemoryBindInfo32 *pImageBinds;
5535     uint32_t signalSemaphoreCount;
5536     const VkSemaphore *pSignalSemaphores;
5537 } VkBindSparseInfo32;
5538
5539 typedef struct VkPresentRegionsKHR32
5540 {
5541     VkStructureType sType;
5542     const void *pNext;
5543     uint32_t swapchainCount;
5544     const VkPresentRegionKHR *pRegions;
5545 } VkPresentRegionsKHR32;
5546
5547 typedef struct VkDeviceGroupPresentInfoKHR32
5548 {
5549     VkStructureType sType;
5550     const void *pNext;
5551     uint32_t swapchainCount;
5552     const uint32_t *pDeviceMasks;
5553     VkDeviceGroupPresentModeFlagBitsKHR mode;
5554 } VkDeviceGroupPresentInfoKHR32;
5555
5556 typedef struct VkPresentIdKHR32
5557 {
5558     VkStructureType sType;
5559     const void *pNext;
5560     uint32_t swapchainCount;
5561     const uint64_t *pPresentIds;
5562 } VkPresentIdKHR32;
5563
5564 typedef struct VkPresentInfoKHR32
5565 {
5566     VkStructureType sType;
5567     const void *pNext;
5568     uint32_t waitSemaphoreCount;
5569     const VkSemaphore *pWaitSemaphores;
5570     uint32_t swapchainCount;
5571     const VkSwapchainKHR *pSwapchains;
5572     const uint32_t *pImageIndices;
5573     VkResult *pResults;
5574 } VkPresentInfoKHR32;
5575
5576 typedef struct VkDeviceGroupSubmitInfo32
5577 {
5578     VkStructureType sType;
5579     const void *pNext;
5580     uint32_t waitSemaphoreCount;
5581     const uint32_t *pWaitSemaphoreDeviceIndices;
5582     uint32_t commandBufferCount;
5583     const uint32_t *pCommandBufferDeviceMasks;
5584     uint32_t signalSemaphoreCount;
5585     const uint32_t *pSignalSemaphoreDeviceIndices;
5586 } VkDeviceGroupSubmitInfo32;
5587 typedef VkDeviceGroupSubmitInfo32 VkDeviceGroupSubmitInfoKHR32;
5588
5589 typedef struct VkProtectedSubmitInfo32
5590 {
5591     VkStructureType sType;
5592     const void *pNext;
5593     VkBool32 protectedSubmit;
5594 } VkProtectedSubmitInfo32;
5595
5596 typedef struct VkPerformanceQuerySubmitInfoKHR32
5597 {
5598     VkStructureType sType;
5599     const void *pNext;
5600     uint32_t counterPassIndex;
5601 } VkPerformanceQuerySubmitInfoKHR32;
5602
5603 typedef struct VkSubmitInfo32
5604 {
5605     VkStructureType sType;
5606     const void *pNext;
5607     uint32_t waitSemaphoreCount;
5608     const VkSemaphore *pWaitSemaphores;
5609     const VkPipelineStageFlags *pWaitDstStageMask;
5610     uint32_t commandBufferCount;
5611     const VkCommandBuffer *pCommandBuffers;
5612     uint32_t signalSemaphoreCount;
5613     const VkSemaphore *pSignalSemaphores;
5614 } VkSubmitInfo32;
5615
5616 typedef struct VkSemaphoreSubmitInfo32
5617 {
5618     VkStructureType sType;
5619     const void *pNext;
5620     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
5621     uint64_t DECLSPEC_ALIGN(8) value;
5622     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
5623     uint32_t deviceIndex;
5624 } VkSemaphoreSubmitInfo32;
5625 typedef VkSemaphoreSubmitInfo32 VkSemaphoreSubmitInfoKHR32;
5626
5627 typedef struct VkCommandBufferSubmitInfo32
5628 {
5629     VkStructureType sType;
5630     const void *pNext;
5631     VkCommandBuffer commandBuffer;
5632     uint32_t deviceMask;
5633 } VkCommandBufferSubmitInfo32;
5634 typedef VkCommandBufferSubmitInfo32 VkCommandBufferSubmitInfoKHR32;
5635
5636 typedef struct VkSubmitInfo232
5637 {
5638     VkStructureType sType;
5639     const void *pNext;
5640     VkSubmitFlags flags;
5641     uint32_t waitSemaphoreInfoCount;
5642     const VkSemaphoreSubmitInfo32 *pWaitSemaphoreInfos;
5643     uint32_t commandBufferInfoCount;
5644     const VkCommandBufferSubmitInfo32 *pCommandBufferInfos;
5645     uint32_t signalSemaphoreInfoCount;
5646     const VkSemaphoreSubmitInfo32 *pSignalSemaphoreInfos;
5647 } VkSubmitInfo232;
5648 typedef VkSubmitInfo232 VkSubmitInfo2KHR32;
5649
5650 typedef struct VkDebugUtilsObjectTagInfoEXT32
5651 {
5652     VkStructureType sType;
5653     const void *pNext;
5654     VkObjectType objectType;
5655     uint64_t DECLSPEC_ALIGN(8) objectHandle;
5656     uint64_t DECLSPEC_ALIGN(8) tagName;
5657     size_t tagSize;
5658     const void *pTag;
5659 } VkDebugUtilsObjectTagInfoEXT32;
5660
5661 typedef struct VkSemaphoreSignalInfo32
5662 {
5663     VkStructureType sType;
5664     const void *pNext;
5665     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
5666     uint64_t DECLSPEC_ALIGN(8) value;
5667 } VkSemaphoreSignalInfo32;
5668 typedef VkSemaphoreSignalInfo32 VkSemaphoreSignalInfoKHR32;
5669
5670 typedef struct VkDeviceAddressBindingCallbackDataEXT32
5671 {
5672     VkStructureType sType;
5673     void *pNext;
5674     VkDeviceAddressBindingFlagsEXT flags;
5675     VkDeviceAddress DECLSPEC_ALIGN(8) baseAddress;
5676     VkDeviceSize DECLSPEC_ALIGN(8) size;
5677     VkDeviceAddressBindingTypeEXT bindingType;
5678 } VkDeviceAddressBindingCallbackDataEXT32;
5679
5680 typedef struct VkDebugUtilsMessengerCallbackDataEXT32
5681 {
5682     VkStructureType sType;
5683     const void *pNext;
5684     VkDebugUtilsMessengerCallbackDataFlagsEXT flags;
5685     const char *pMessageIdName;
5686     int32_t messageIdNumber;
5687     const char *pMessage;
5688     uint32_t queueLabelCount;
5689     const VkDebugUtilsLabelEXT32 *pQueueLabels;
5690     uint32_t cmdBufLabelCount;
5691     const VkDebugUtilsLabelEXT32 *pCmdBufLabels;
5692     uint32_t objectCount;
5693     const VkDebugUtilsObjectNameInfoEXT32 *pObjects;
5694 } VkDebugUtilsMessengerCallbackDataEXT32;
5695
5696 typedef struct VkCopyDescriptorSet32
5697 {
5698     VkStructureType sType;
5699     const void *pNext;
5700     VkDescriptorSet DECLSPEC_ALIGN(8) srcSet;
5701     uint32_t srcBinding;
5702     uint32_t srcArrayElement;
5703     VkDescriptorSet DECLSPEC_ALIGN(8) dstSet;
5704     uint32_t dstBinding;
5705     uint32_t dstArrayElement;
5706     uint32_t descriptorCount;
5707 } VkCopyDescriptorSet32;
5708
5709 typedef struct VkSemaphoreWaitInfo32
5710 {
5711     VkStructureType sType;
5712     const void *pNext;
5713     VkSemaphoreWaitFlags flags;
5714     uint32_t semaphoreCount;
5715     const VkSemaphore *pSemaphores;
5716     const uint64_t *pValues;
5717 } VkSemaphoreWaitInfo32;
5718 typedef VkSemaphoreWaitInfo32 VkSemaphoreWaitInfoKHR32;
5719
5720 #endif /* USE_STRUCT_CONVERSION */
5721
5722 static uint64_t wine_vk_unwrap_handle(uint32_t type, uint64_t handle)
5723 {
5724     switch(type)
5725     {
5726     case VK_OBJECT_TYPE_COMMAND_BUFFER:
5727         return (uint64_t) (uintptr_t) wine_cmd_buffer_from_handle(((VkCommandBuffer) (uintptr_t) handle))->command_buffer;
5728     case VK_OBJECT_TYPE_COMMAND_POOL:
5729         return (uint64_t) wine_cmd_pool_from_handle(handle)->command_pool;
5730     case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT:
5731         return (uint64_t) wine_debug_report_callback_from_handle(handle)->debug_callback;
5732     case VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT:
5733         return (uint64_t) wine_debug_utils_messenger_from_handle(handle)->debug_messenger;
5734     case VK_OBJECT_TYPE_DEVICE:
5735         return (uint64_t) (uintptr_t) wine_device_from_handle(((VkDevice) (uintptr_t) handle))->device;
5736     case VK_OBJECT_TYPE_INSTANCE:
5737         return (uint64_t) (uintptr_t) wine_instance_from_handle(((VkInstance) (uintptr_t) handle))->instance;
5738     case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
5739         return (uint64_t) (uintptr_t) wine_phys_dev_from_handle(((VkPhysicalDevice) (uintptr_t) handle))->phys_dev;
5740     case VK_OBJECT_TYPE_QUEUE:
5741         return (uint64_t) (uintptr_t) wine_queue_from_handle(((VkQueue) (uintptr_t) handle))->queue;
5742     case VK_OBJECT_TYPE_SURFACE_KHR:
5743         return (uint64_t) wine_surface_from_handle(handle)->surface;
5744     default:
5745        return handle;
5746     }
5747 }
5748
5749 #if defined(USE_STRUCT_CONVERSION)
5750 static inline void convert_VkAcquireNextImageInfoKHR_win32_to_host(const VkAcquireNextImageInfoKHR32 *in, VkAcquireNextImageInfoKHR *out)
5751 {
5752     if (!in) return;
5753
5754     out->sType = in->sType;
5755     out->pNext = in->pNext;
5756     out->swapchain = in->swapchain;
5757     out->timeout = in->timeout;
5758     out->semaphore = in->semaphore;
5759     out->fence = in->fence;
5760     out->deviceMask = in->deviceMask;
5761 }
5762 #endif /* USE_STRUCT_CONVERSION */
5763
5764 #if defined(USE_STRUCT_CONVERSION)
5765 static inline void convert_VkPerformanceConfigurationAcquireInfoINTEL_win32_to_host(const VkPerformanceConfigurationAcquireInfoINTEL32 *in, VkPerformanceConfigurationAcquireInfoINTEL *out)
5766 {
5767     if (!in) return;
5768
5769     out->sType = in->sType;
5770     out->pNext = in->pNext;
5771     out->type = in->type;
5772 }
5773 #endif /* USE_STRUCT_CONVERSION */
5774
5775 #if defined(USE_STRUCT_CONVERSION)
5776 static inline void convert_VkAcquireProfilingLockInfoKHR_win32_to_host(const VkAcquireProfilingLockInfoKHR32 *in, VkAcquireProfilingLockInfoKHR *out)
5777 {
5778     if (!in) return;
5779
5780     out->sType = in->sType;
5781     out->pNext = in->pNext;
5782     out->flags = in->flags;
5783     out->timeout = in->timeout;
5784 }
5785 #endif /* USE_STRUCT_CONVERSION */
5786
5787 #if defined(USE_STRUCT_CONVERSION)
5788 static inline void convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host(const VkCommandBufferAllocateInfo32 *in, VkCommandBufferAllocateInfo *out)
5789 {
5790     if (!in) return;
5791
5792     out->sType = in->sType;
5793     out->pNext = in->pNext;
5794     out->commandPool = in->commandPool;
5795     out->level = in->level;
5796     out->commandBufferCount = in->commandBufferCount;
5797 }
5798 #endif /* USE_STRUCT_CONVERSION */
5799
5800 #if defined(USE_STRUCT_CONVERSION)
5801 static inline void convert_VkDescriptorSetAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetAllocateInfo32 *in, VkDescriptorSetAllocateInfo *out)
5802 {
5803     const VkBaseInStructure *in_header;
5804     VkBaseOutStructure *out_header = (void *)out;
5805
5806     if (!in) return;
5807
5808     out->sType = in->sType;
5809     out->pNext = NULL;
5810     out->descriptorPool = in->descriptorPool;
5811     out->descriptorSetCount = in->descriptorSetCount;
5812     out->pSetLayouts = in->pSetLayouts;
5813
5814     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
5815     {
5816         switch (in_header->sType)
5817         {
5818         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
5819         {
5820             VkDescriptorSetVariableDescriptorCountAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5821             const VkDescriptorSetVariableDescriptorCountAllocateInfo32 *in_ext = (const VkDescriptorSetVariableDescriptorCountAllocateInfo32 *)in_header;
5822             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
5823             out_ext->pNext = NULL;
5824             out_ext->descriptorSetCount = in_ext->descriptorSetCount;
5825             out_ext->pDescriptorCounts = in_ext->pDescriptorCounts;
5826             out_header->pNext = (void *)out_ext;
5827             out_header = (void *)out_ext;
5828             break;
5829         }
5830         default:
5831             FIXME("Unhandled sType %u.", in_header->sType);
5832             break;
5833         }
5834     }
5835 }
5836 #endif /* USE_STRUCT_CONVERSION */
5837
5838 #if defined(USE_STRUCT_CONVERSION)
5839 static inline void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkMemoryAllocateInfo32 *in, VkMemoryAllocateInfo *out)
5840 {
5841     const VkBaseInStructure *in_header;
5842     VkBaseOutStructure *out_header = (void *)out;
5843
5844     if (!in) return;
5845
5846     out->sType = in->sType;
5847     out->pNext = NULL;
5848     out->allocationSize = in->allocationSize;
5849     out->memoryTypeIndex = in->memoryTypeIndex;
5850
5851     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
5852     {
5853         switch (in_header->sType)
5854         {
5855         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
5856         {
5857             VkDedicatedAllocationMemoryAllocateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5858             const VkDedicatedAllocationMemoryAllocateInfoNV32 *in_ext = (const VkDedicatedAllocationMemoryAllocateInfoNV32 *)in_header;
5859             out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV;
5860             out_ext->pNext = NULL;
5861             out_ext->image = in_ext->image;
5862             out_ext->buffer = in_ext->buffer;
5863             out_header->pNext = (void *)out_ext;
5864             out_header = (void *)out_ext;
5865             break;
5866         }
5867         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
5868         {
5869             VkExportMemoryAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5870             const VkExportMemoryAllocateInfo32 *in_ext = (const VkExportMemoryAllocateInfo32 *)in_header;
5871             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO;
5872             out_ext->pNext = NULL;
5873             out_ext->handleTypes = in_ext->handleTypes;
5874             out_header->pNext = (void *)out_ext;
5875             out_header = (void *)out_ext;
5876             break;
5877         }
5878         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
5879         {
5880             VkImportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5881             const VkImportMemoryWin32HandleInfoKHR32 *in_ext = (const VkImportMemoryWin32HandleInfoKHR32 *)in_header;
5882             out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
5883             out_ext->pNext = NULL;
5884             out_ext->handleType = in_ext->handleType;
5885             out_ext->handle = in_ext->handle;
5886             out_ext->name = in_ext->name;
5887             out_header->pNext = (void *)out_ext;
5888             out_header = (void *)out_ext;
5889             break;
5890         }
5891         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
5892         {
5893             VkExportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5894             const VkExportMemoryWin32HandleInfoKHR32 *in_ext = (const VkExportMemoryWin32HandleInfoKHR32 *)in_header;
5895             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
5896             out_ext->pNext = NULL;
5897             out_ext->pAttributes = in_ext->pAttributes;
5898             out_ext->dwAccess = in_ext->dwAccess;
5899             out_ext->name = in_ext->name;
5900             out_header->pNext = (void *)out_ext;
5901             out_header = (void *)out_ext;
5902             break;
5903         }
5904         case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
5905         {
5906             VkMemoryAllocateFlagsInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5907             const VkMemoryAllocateFlagsInfo32 *in_ext = (const VkMemoryAllocateFlagsInfo32 *)in_header;
5908             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO;
5909             out_ext->pNext = NULL;
5910             out_ext->flags = in_ext->flags;
5911             out_ext->deviceMask = in_ext->deviceMask;
5912             out_header->pNext = (void *)out_ext;
5913             out_header = (void *)out_ext;
5914             break;
5915         }
5916         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
5917         {
5918             VkMemoryDedicatedAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5919             const VkMemoryDedicatedAllocateInfo32 *in_ext = (const VkMemoryDedicatedAllocateInfo32 *)in_header;
5920             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
5921             out_ext->pNext = NULL;
5922             out_ext->image = in_ext->image;
5923             out_ext->buffer = in_ext->buffer;
5924             out_header->pNext = (void *)out_ext;
5925             out_header = (void *)out_ext;
5926             break;
5927         }
5928         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
5929         {
5930             VkImportMemoryHostPointerInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5931             const VkImportMemoryHostPointerInfoEXT32 *in_ext = (const VkImportMemoryHostPointerInfoEXT32 *)in_header;
5932             out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT;
5933             out_ext->pNext = NULL;
5934             out_ext->handleType = in_ext->handleType;
5935             out_ext->pHostPointer = in_ext->pHostPointer;
5936             out_header->pNext = (void *)out_ext;
5937             out_header = (void *)out_ext;
5938             break;
5939         }
5940         case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
5941         {
5942             VkMemoryPriorityAllocateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5943             const VkMemoryPriorityAllocateInfoEXT32 *in_ext = (const VkMemoryPriorityAllocateInfoEXT32 *)in_header;
5944             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT;
5945             out_ext->pNext = NULL;
5946             out_ext->priority = in_ext->priority;
5947             out_header->pNext = (void *)out_ext;
5948             out_header = (void *)out_ext;
5949             break;
5950         }
5951         case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
5952         {
5953             VkMemoryOpaqueCaptureAddressAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5954             const VkMemoryOpaqueCaptureAddressAllocateInfo32 *in_ext = (const VkMemoryOpaqueCaptureAddressAllocateInfo32 *)in_header;
5955             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO;
5956             out_ext->pNext = NULL;
5957             out_ext->opaqueCaptureAddress = in_ext->opaqueCaptureAddress;
5958             out_header->pNext = (void *)out_ext;
5959             out_header = (void *)out_ext;
5960             break;
5961         }
5962         default:
5963             FIXME("Unhandled sType %u.", in_header->sType);
5964             break;
5965         }
5966     }
5967 }
5968 #endif /* USE_STRUCT_CONVERSION */
5969
5970 #if defined(USE_STRUCT_CONVERSION)
5971 static inline void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, VkCommandBufferInheritanceInfo *out)
5972 {
5973     const VkBaseInStructure *in_header;
5974     VkBaseOutStructure *out_header = (void *)out;
5975
5976     if (!in) return;
5977
5978     out->sType = in->sType;
5979     out->pNext = NULL;
5980     out->renderPass = in->renderPass;
5981     out->subpass = in->subpass;
5982     out->framebuffer = in->framebuffer;
5983     out->occlusionQueryEnable = in->occlusionQueryEnable;
5984     out->queryFlags = in->queryFlags;
5985     out->pipelineStatistics = in->pipelineStatistics;
5986
5987     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
5988     {
5989         switch (in_header->sType)
5990         {
5991         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
5992         {
5993             VkCommandBufferInheritanceConditionalRenderingInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5994             const VkCommandBufferInheritanceConditionalRenderingInfoEXT32 *in_ext = (const VkCommandBufferInheritanceConditionalRenderingInfoEXT32 *)in_header;
5995             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT;
5996             out_ext->pNext = NULL;
5997             out_ext->conditionalRenderingEnable = in_ext->conditionalRenderingEnable;
5998             out_header->pNext = (void *)out_ext;
5999             out_header = (void *)out_ext;
6000             break;
6001         }
6002         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
6003         {
6004             VkCommandBufferInheritanceRenderPassTransformInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6005             const VkCommandBufferInheritanceRenderPassTransformInfoQCOM32 *in_ext = (const VkCommandBufferInheritanceRenderPassTransformInfoQCOM32 *)in_header;
6006             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM;
6007             out_ext->pNext = NULL;
6008             out_ext->transform = in_ext->transform;
6009             out_ext->renderArea = in_ext->renderArea;
6010             out_header->pNext = (void *)out_ext;
6011             out_header = (void *)out_ext;
6012             break;
6013         }
6014         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
6015         {
6016             VkCommandBufferInheritanceViewportScissorInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6017             const VkCommandBufferInheritanceViewportScissorInfoNV32 *in_ext = (const VkCommandBufferInheritanceViewportScissorInfoNV32 *)in_header;
6018             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV;
6019             out_ext->pNext = NULL;
6020             out_ext->viewportScissor2D = in_ext->viewportScissor2D;
6021             out_ext->viewportDepthCount = in_ext->viewportDepthCount;
6022             out_ext->pViewportDepths = in_ext->pViewportDepths;
6023             out_header->pNext = (void *)out_ext;
6024             out_header = (void *)out_ext;
6025             break;
6026         }
6027         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
6028         {
6029             VkCommandBufferInheritanceRenderingInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6030             const VkCommandBufferInheritanceRenderingInfo32 *in_ext = (const VkCommandBufferInheritanceRenderingInfo32 *)in_header;
6031             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO;
6032             out_ext->pNext = NULL;
6033             out_ext->flags = in_ext->flags;
6034             out_ext->viewMask = in_ext->viewMask;
6035             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
6036             out_ext->pColorAttachmentFormats = in_ext->pColorAttachmentFormats;
6037             out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
6038             out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
6039             out_ext->rasterizationSamples = in_ext->rasterizationSamples;
6040             out_header->pNext = (void *)out_ext;
6041             out_header = (void *)out_ext;
6042             break;
6043         }
6044         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
6045         {
6046             VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6047             const VkAttachmentSampleCountInfoAMD32 *in_ext = (const VkAttachmentSampleCountInfoAMD32 *)in_header;
6048             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
6049             out_ext->pNext = NULL;
6050             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
6051             out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples;
6052             out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
6053             out_header->pNext = (void *)out_ext;
6054             out_header = (void *)out_ext;
6055             break;
6056         }
6057         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
6058         {
6059             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6060             const VkMultiviewPerViewAttributesInfoNVX32 *in_ext = (const VkMultiviewPerViewAttributesInfoNVX32 *)in_header;
6061             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
6062             out_ext->pNext = NULL;
6063             out_ext->perViewAttributes = in_ext->perViewAttributes;
6064             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
6065             out_header->pNext = (void *)out_ext;
6066             out_header = (void *)out_ext;
6067             break;
6068         }
6069         default:
6070             FIXME("Unhandled sType %u.", in_header->sType);
6071             break;
6072         }
6073     }
6074 }
6075 #endif /* USE_STRUCT_CONVERSION */
6076
6077 #if defined(USE_STRUCT_CONVERSION)
6078 static inline const VkCommandBufferInheritanceInfo *convert_VkCommandBufferInheritanceInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, uint32_t count)
6079 {
6080     VkCommandBufferInheritanceInfo *out;
6081     unsigned int i;
6082
6083     if (!in || !count) return NULL;
6084
6085     out = conversion_context_alloc(ctx, count * sizeof(*out));
6086     for (i = 0; i < count; i++)
6087     {
6088         convert_VkCommandBufferInheritanceInfo_win32_to_host(ctx, &in[i], &out[i]);
6089     }
6090
6091     return out;
6092 }
6093 #endif /* USE_STRUCT_CONVERSION */
6094
6095 #if defined(USE_STRUCT_CONVERSION)
6096 static inline void convert_VkCommandBufferBeginInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferBeginInfo32 *in, VkCommandBufferBeginInfo *out)
6097 {
6098     const VkBaseInStructure *in_header;
6099     VkBaseOutStructure *out_header = (void *)out;
6100
6101     if (!in) return;
6102
6103     out->sType = in->sType;
6104     out->pNext = NULL;
6105     out->flags = in->flags;
6106     out->pInheritanceInfo = convert_VkCommandBufferInheritanceInfo_array_win32_to_host(ctx, in->pInheritanceInfo, 1);
6107
6108     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
6109     {
6110         switch (in_header->sType)
6111         {
6112         case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
6113         {
6114             VkDeviceGroupCommandBufferBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6115             const VkDeviceGroupCommandBufferBeginInfo32 *in_ext = (const VkDeviceGroupCommandBufferBeginInfo32 *)in_header;
6116             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO;
6117             out_ext->pNext = NULL;
6118             out_ext->deviceMask = in_ext->deviceMask;
6119             out_header->pNext = (void *)out_ext;
6120             out_header = (void *)out_ext;
6121             break;
6122         }
6123         default:
6124             FIXME("Unhandled sType %u.", in_header->sType);
6125             break;
6126         }
6127     }
6128 }
6129 #endif /* USE_STRUCT_CONVERSION */
6130
6131 #if defined(USE_STRUCT_CONVERSION)
6132 static inline void convert_VkBindAccelerationStructureMemoryInfoNV_win32_to_host(const VkBindAccelerationStructureMemoryInfoNV32 *in, VkBindAccelerationStructureMemoryInfoNV *out)
6133 {
6134     if (!in) return;
6135
6136     out->sType = in->sType;
6137     out->pNext = in->pNext;
6138     out->accelerationStructure = in->accelerationStructure;
6139     out->memory = in->memory;
6140     out->memoryOffset = in->memoryOffset;
6141     out->deviceIndexCount = in->deviceIndexCount;
6142     out->pDeviceIndices = in->pDeviceIndices;
6143 }
6144 #endif /* USE_STRUCT_CONVERSION */
6145
6146 #if defined(USE_STRUCT_CONVERSION)
6147 static inline const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccelerationStructureMemoryInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkBindAccelerationStructureMemoryInfoNV32 *in, uint32_t count)
6148 {
6149     VkBindAccelerationStructureMemoryInfoNV *out;
6150     unsigned int i;
6151
6152     if (!in || !count) return NULL;
6153
6154     out = conversion_context_alloc(ctx, count * sizeof(*out));
6155     for (i = 0; i < count; i++)
6156     {
6157         convert_VkBindAccelerationStructureMemoryInfoNV_win32_to_host(&in[i], &out[i]);
6158     }
6159
6160     return out;
6161 }
6162 #endif /* USE_STRUCT_CONVERSION */
6163
6164 #if defined(USE_STRUCT_CONVERSION)
6165 static inline void convert_VkBindBufferMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo32 *in, VkBindBufferMemoryInfo *out)
6166 {
6167     const VkBaseInStructure *in_header;
6168     VkBaseOutStructure *out_header = (void *)out;
6169
6170     if (!in) return;
6171
6172     out->sType = in->sType;
6173     out->pNext = NULL;
6174     out->buffer = in->buffer;
6175     out->memory = in->memory;
6176     out->memoryOffset = in->memoryOffset;
6177
6178     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
6179     {
6180         switch (in_header->sType)
6181         {
6182         case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
6183         {
6184             VkBindBufferMemoryDeviceGroupInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6185             const VkBindBufferMemoryDeviceGroupInfo32 *in_ext = (const VkBindBufferMemoryDeviceGroupInfo32 *)in_header;
6186             out_ext->sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO;
6187             out_ext->pNext = NULL;
6188             out_ext->deviceIndexCount = in_ext->deviceIndexCount;
6189             out_ext->pDeviceIndices = in_ext->pDeviceIndices;
6190             out_header->pNext = (void *)out_ext;
6191             out_header = (void *)out_ext;
6192             break;
6193         }
6194         default:
6195             FIXME("Unhandled sType %u.", in_header->sType);
6196             break;
6197         }
6198     }
6199 }
6200 #endif /* USE_STRUCT_CONVERSION */
6201
6202 #if defined(USE_STRUCT_CONVERSION)
6203 static inline const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo32 *in, uint32_t count)
6204 {
6205     VkBindBufferMemoryInfo *out;
6206     unsigned int i;
6207
6208     if (!in || !count) return NULL;
6209
6210     out = conversion_context_alloc(ctx, count * sizeof(*out));
6211     for (i = 0; i < count; i++)
6212     {
6213         convert_VkBindBufferMemoryInfo_win32_to_host(ctx, &in[i], &out[i]);
6214     }
6215
6216     return out;
6217 }
6218 #endif /* USE_STRUCT_CONVERSION */
6219
6220 #if defined(USE_STRUCT_CONVERSION)
6221 static inline void convert_VkBindImageMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, VkBindImageMemoryInfo *out)
6222 {
6223     const VkBaseInStructure *in_header;
6224     VkBaseOutStructure *out_header = (void *)out;
6225
6226     if (!in) return;
6227
6228     out->sType = in->sType;
6229     out->pNext = NULL;
6230     out->image = in->image;
6231     out->memory = in->memory;
6232     out->memoryOffset = in->memoryOffset;
6233
6234     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
6235     {
6236         switch (in_header->sType)
6237         {
6238         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
6239         {
6240             VkBindImageMemoryDeviceGroupInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6241             const VkBindImageMemoryDeviceGroupInfo32 *in_ext = (const VkBindImageMemoryDeviceGroupInfo32 *)in_header;
6242             out_ext->sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO;
6243             out_ext->pNext = NULL;
6244             out_ext->deviceIndexCount = in_ext->deviceIndexCount;
6245             out_ext->pDeviceIndices = in_ext->pDeviceIndices;
6246             out_ext->splitInstanceBindRegionCount = in_ext->splitInstanceBindRegionCount;
6247             out_ext->pSplitInstanceBindRegions = in_ext->pSplitInstanceBindRegions;
6248             out_header->pNext = (void *)out_ext;
6249             out_header = (void *)out_ext;
6250             break;
6251         }
6252         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
6253         {
6254             VkBindImageMemorySwapchainInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6255             const VkBindImageMemorySwapchainInfoKHR32 *in_ext = (const VkBindImageMemorySwapchainInfoKHR32 *)in_header;
6256             out_ext->sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR;
6257             out_ext->pNext = NULL;
6258             out_ext->swapchain = in_ext->swapchain;
6259             out_ext->imageIndex = in_ext->imageIndex;
6260             out_header->pNext = (void *)out_ext;
6261             out_header = (void *)out_ext;
6262             break;
6263         }
6264         case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
6265         {
6266             VkBindImagePlaneMemoryInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6267             const VkBindImagePlaneMemoryInfo32 *in_ext = (const VkBindImagePlaneMemoryInfo32 *)in_header;
6268             out_ext->sType = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO;
6269             out_ext->pNext = NULL;
6270             out_ext->planeAspect = in_ext->planeAspect;
6271             out_header->pNext = (void *)out_ext;
6272             out_header = (void *)out_ext;
6273             break;
6274         }
6275         default:
6276             FIXME("Unhandled sType %u.", in_header->sType);
6277             break;
6278         }
6279     }
6280 }
6281 #endif /* USE_STRUCT_CONVERSION */
6282
6283 #if defined(USE_STRUCT_CONVERSION)
6284 static inline const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, uint32_t count)
6285 {
6286     VkBindImageMemoryInfo *out;
6287     unsigned int i;
6288
6289     if (!in || !count) return NULL;
6290
6291     out = conversion_context_alloc(ctx, count * sizeof(*out));
6292     for (i = 0; i < count; i++)
6293     {
6294         convert_VkBindImageMemoryInfo_win32_to_host(ctx, &in[i], &out[i]);
6295     }
6296
6297     return out;
6298 }
6299 #endif /* USE_STRUCT_CONVERSION */
6300
6301 #if defined(USE_STRUCT_CONVERSION)
6302 static inline void convert_VkAccelerationStructureGeometryKHR_win32_to_host(const VkAccelerationStructureGeometryKHR32 *in, VkAccelerationStructureGeometryKHR *out)
6303 {
6304     if (!in) return;
6305
6306     out->sType = in->sType;
6307     out->pNext = in->pNext;
6308     out->geometryType = in->geometryType;
6309     out->geometry = in->geometry;
6310     out->flags = in->flags;
6311 }
6312 #endif /* USE_STRUCT_CONVERSION */
6313
6314 #if defined(USE_STRUCT_CONVERSION)
6315 static inline const VkAccelerationStructureGeometryKHR *convert_VkAccelerationStructureGeometryKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, uint32_t count)
6316 {
6317     VkAccelerationStructureGeometryKHR *out;
6318     unsigned int i;
6319
6320     if (!in || !count) return NULL;
6321
6322     out = conversion_context_alloc(ctx, count * sizeof(*out));
6323     for (i = 0; i < count; i++)
6324     {
6325         convert_VkAccelerationStructureGeometryKHR_win32_to_host(&in[i], &out[i]);
6326     }
6327
6328     return out;
6329 }
6330 #endif /* USE_STRUCT_CONVERSION */
6331
6332 #if defined(USE_STRUCT_CONVERSION)
6333 static inline const VkAccelerationStructureGeometryKHR * const*convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 * const*in, uint32_t count)
6334 {
6335     VkAccelerationStructureGeometryKHR **out;
6336     unsigned int i;
6337
6338     if (!in || !count) return NULL;
6339
6340     out = conversion_context_alloc(ctx, count * sizeof(*out));
6341     for (i = 0; i < count; i++)
6342     {
6343         if (in[i])
6344         {
6345             out[i] = conversion_context_alloc(ctx, sizeof(*out[i]));
6346             convert_VkAccelerationStructureGeometryKHR_win32_to_host(in[i], out[i]);
6347         }
6348         else
6349             out[i] = NULL;
6350     }
6351
6352     return (void *)out;
6353 }
6354 #endif /* USE_STRUCT_CONVERSION */
6355
6356 #if defined(USE_STRUCT_CONVERSION)
6357 static inline void convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, VkAccelerationStructureBuildGeometryInfoKHR *out)
6358 {
6359     if (!in) return;
6360
6361     out->sType = in->sType;
6362     out->pNext = in->pNext;
6363     out->type = in->type;
6364     out->flags = in->flags;
6365     out->mode = in->mode;
6366     out->srcAccelerationStructure = in->srcAccelerationStructure;
6367     out->dstAccelerationStructure = in->dstAccelerationStructure;
6368     out->geometryCount = in->geometryCount;
6369     out->pGeometries = convert_VkAccelerationStructureGeometryKHR_array_win32_to_host(ctx, in->pGeometries, in->geometryCount);
6370     out->ppGeometries = convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(ctx, in->ppGeometries, in->geometryCount);
6371     out->scratchData = in->scratchData;
6372 }
6373 #endif /* USE_STRUCT_CONVERSION */
6374
6375 #if defined(USE_STRUCT_CONVERSION)
6376 static inline const VkAccelerationStructureBuildGeometryInfoKHR *convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, uint32_t count)
6377 {
6378     VkAccelerationStructureBuildGeometryInfoKHR *out;
6379     unsigned int i;
6380
6381     if (!in || !count) return NULL;
6382
6383     out = conversion_context_alloc(ctx, count * sizeof(*out));
6384     for (i = 0; i < count; i++)
6385     {
6386         convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(ctx, &in[i], &out[i]);
6387     }
6388
6389     return out;
6390 }
6391 #endif /* USE_STRUCT_CONVERSION */
6392
6393 #if defined(USE_STRUCT_CONVERSION)
6394 static inline void convert_VkMicromapBuildInfoEXT_win32_to_host(const VkMicromapBuildInfoEXT32 *in, VkMicromapBuildInfoEXT *out)
6395 {
6396     if (!in) return;
6397
6398     out->sType = in->sType;
6399     out->pNext = in->pNext;
6400     out->type = in->type;
6401     out->flags = in->flags;
6402     out->mode = in->mode;
6403     out->dstMicromap = in->dstMicromap;
6404     out->usageCountsCount = in->usageCountsCount;
6405     out->pUsageCounts = in->pUsageCounts;
6406     out->ppUsageCounts = in->ppUsageCounts;
6407     out->data = in->data;
6408     out->scratchData = in->scratchData;
6409     out->triangleArray = in->triangleArray;
6410     out->triangleArrayStride = in->triangleArrayStride;
6411 }
6412 #endif /* USE_STRUCT_CONVERSION */
6413
6414 #if defined(USE_STRUCT_CONVERSION)
6415 static inline const VkMicromapBuildInfoEXT *convert_VkMicromapBuildInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT32 *in, uint32_t count)
6416 {
6417     VkMicromapBuildInfoEXT *out;
6418     unsigned int i;
6419
6420     if (!in || !count) return NULL;
6421
6422     out = conversion_context_alloc(ctx, count * sizeof(*out));
6423     for (i = 0; i < count; i++)
6424     {
6425         convert_VkMicromapBuildInfoEXT_win32_to_host(&in[i], &out[i]);
6426     }
6427
6428     return out;
6429 }
6430 #endif /* USE_STRUCT_CONVERSION */
6431
6432 #if defined(USE_STRUCT_CONVERSION)
6433 static inline void convert_VkConditionalRenderingBeginInfoEXT_win32_to_host(const VkConditionalRenderingBeginInfoEXT32 *in, VkConditionalRenderingBeginInfoEXT *out)
6434 {
6435     if (!in) return;
6436
6437     out->sType = in->sType;
6438     out->pNext = in->pNext;
6439     out->buffer = in->buffer;
6440     out->offset = in->offset;
6441     out->flags = in->flags;
6442 }
6443 #endif /* USE_STRUCT_CONVERSION */
6444
6445 #if defined(USE_STRUCT_CONVERSION)
6446 static inline void convert_VkDebugUtilsLabelEXT_win32_to_host(const VkDebugUtilsLabelEXT32 *in, VkDebugUtilsLabelEXT *out)
6447 {
6448     if (!in) return;
6449
6450     out->sType = in->sType;
6451     out->pNext = in->pNext;
6452     out->pLabelName = in->pLabelName;
6453     memcpy(out->color, in->color, 4 * sizeof(float));
6454 }
6455 #endif /* USE_STRUCT_CONVERSION */
6456
6457 #if defined(USE_STRUCT_CONVERSION)
6458 static inline void convert_VkSampleLocationsInfoEXT_win32_to_host(const VkSampleLocationsInfoEXT32 *in, VkSampleLocationsInfoEXT *out)
6459 {
6460     if (!in) return;
6461
6462     out->sType = in->sType;
6463     out->pNext = in->pNext;
6464     out->sampleLocationsPerPixel = in->sampleLocationsPerPixel;
6465     out->sampleLocationGridSize = in->sampleLocationGridSize;
6466     out->sampleLocationsCount = in->sampleLocationsCount;
6467     out->pSampleLocations = in->pSampleLocations;
6468 }
6469 #endif /* USE_STRUCT_CONVERSION */
6470
6471 #if defined(USE_STRUCT_CONVERSION)
6472 static inline void convert_VkAttachmentSampleLocationsEXT_win32_to_host(const VkAttachmentSampleLocationsEXT32 *in, VkAttachmentSampleLocationsEXT *out)
6473 {
6474     if (!in) return;
6475
6476     out->attachmentIndex = in->attachmentIndex;
6477     convert_VkSampleLocationsInfoEXT_win32_to_host(&in->sampleLocationsInfo, &out->sampleLocationsInfo);
6478 }
6479 #endif /* USE_STRUCT_CONVERSION */
6480
6481 #if defined(USE_STRUCT_CONVERSION)
6482 static inline const VkAttachmentSampleLocationsEXT *convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentSampleLocationsEXT32 *in, uint32_t count)
6483 {
6484     VkAttachmentSampleLocationsEXT *out;
6485     unsigned int i;
6486
6487     if (!in || !count) return NULL;
6488
6489     out = conversion_context_alloc(ctx, count * sizeof(*out));
6490     for (i = 0; i < count; i++)
6491     {
6492         convert_VkAttachmentSampleLocationsEXT_win32_to_host(&in[i], &out[i]);
6493     }
6494
6495     return out;
6496 }
6497 #endif /* USE_STRUCT_CONVERSION */
6498
6499 #if defined(USE_STRUCT_CONVERSION)
6500 static inline void convert_VkSubpassSampleLocationsEXT_win32_to_host(const VkSubpassSampleLocationsEXT32 *in, VkSubpassSampleLocationsEXT *out)
6501 {
6502     if (!in) return;
6503
6504     out->subpassIndex = in->subpassIndex;
6505     convert_VkSampleLocationsInfoEXT_win32_to_host(&in->sampleLocationsInfo, &out->sampleLocationsInfo);
6506 }
6507 #endif /* USE_STRUCT_CONVERSION */
6508
6509 #if defined(USE_STRUCT_CONVERSION)
6510 static inline const VkSubpassSampleLocationsEXT *convert_VkSubpassSampleLocationsEXT_array_win32_to_host(struct conversion_context *ctx, const VkSubpassSampleLocationsEXT32 *in, uint32_t count)
6511 {
6512     VkSubpassSampleLocationsEXT *out;
6513     unsigned int i;
6514
6515     if (!in || !count) return NULL;
6516
6517     out = conversion_context_alloc(ctx, count * sizeof(*out));
6518     for (i = 0; i < count; i++)
6519     {
6520         convert_VkSubpassSampleLocationsEXT_win32_to_host(&in[i], &out[i]);
6521     }
6522
6523     return out;
6524 }
6525 #endif /* USE_STRUCT_CONVERSION */
6526
6527 #if defined(USE_STRUCT_CONVERSION)
6528 static inline void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion_context *ctx, const VkRenderPassBeginInfo32 *in, VkRenderPassBeginInfo *out)
6529 {
6530     const VkBaseInStructure *in_header;
6531     VkBaseOutStructure *out_header = (void *)out;
6532
6533     if (!in) return;
6534
6535     out->sType = in->sType;
6536     out->pNext = NULL;
6537     out->renderPass = in->renderPass;
6538     out->framebuffer = in->framebuffer;
6539     out->renderArea = in->renderArea;
6540     out->clearValueCount = in->clearValueCount;
6541     out->pClearValues = in->pClearValues;
6542
6543     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
6544     {
6545         switch (in_header->sType)
6546         {
6547         case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
6548         {
6549             VkDeviceGroupRenderPassBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6550             const VkDeviceGroupRenderPassBeginInfo32 *in_ext = (const VkDeviceGroupRenderPassBeginInfo32 *)in_header;
6551             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
6552             out_ext->pNext = NULL;
6553             out_ext->deviceMask = in_ext->deviceMask;
6554             out_ext->deviceRenderAreaCount = in_ext->deviceRenderAreaCount;
6555             out_ext->pDeviceRenderAreas = in_ext->pDeviceRenderAreas;
6556             out_header->pNext = (void *)out_ext;
6557             out_header = (void *)out_ext;
6558             break;
6559         }
6560         case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
6561         {
6562             VkRenderPassSampleLocationsBeginInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6563             const VkRenderPassSampleLocationsBeginInfoEXT32 *in_ext = (const VkRenderPassSampleLocationsBeginInfoEXT32 *)in_header;
6564             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT;
6565             out_ext->pNext = NULL;
6566             out_ext->attachmentInitialSampleLocationsCount = in_ext->attachmentInitialSampleLocationsCount;
6567             out_ext->pAttachmentInitialSampleLocations = convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(ctx, in_ext->pAttachmentInitialSampleLocations, in_ext->attachmentInitialSampleLocationsCount);
6568             out_ext->postSubpassSampleLocationsCount = in_ext->postSubpassSampleLocationsCount;
6569             out_ext->pPostSubpassSampleLocations = convert_VkSubpassSampleLocationsEXT_array_win32_to_host(ctx, in_ext->pPostSubpassSampleLocations, in_ext->postSubpassSampleLocationsCount);
6570             out_header->pNext = (void *)out_ext;
6571             out_header = (void *)out_ext;
6572             break;
6573         }
6574         case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
6575         {
6576             VkRenderPassAttachmentBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6577             const VkRenderPassAttachmentBeginInfo32 *in_ext = (const VkRenderPassAttachmentBeginInfo32 *)in_header;
6578             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO;
6579             out_ext->pNext = NULL;
6580             out_ext->attachmentCount = in_ext->attachmentCount;
6581             out_ext->pAttachments = in_ext->pAttachments;
6582             out_header->pNext = (void *)out_ext;
6583             out_header = (void *)out_ext;
6584             break;
6585         }
6586         case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
6587         {
6588             VkRenderPassTransformBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6589             const VkRenderPassTransformBeginInfoQCOM32 *in_ext = (const VkRenderPassTransformBeginInfoQCOM32 *)in_header;
6590             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM;
6591             out_ext->pNext = NULL;
6592             out_ext->transform = in_ext->transform;
6593             out_header->pNext = (void *)out_ext;
6594             out_header = (void *)out_ext;
6595             break;
6596         }
6597         default:
6598             FIXME("Unhandled sType %u.", in_header->sType);
6599             break;
6600         }
6601     }
6602 }
6603 #endif /* USE_STRUCT_CONVERSION */
6604
6605 #if defined(USE_STRUCT_CONVERSION)
6606 static inline void convert_VkSubpassBeginInfo_win32_to_host(const VkSubpassBeginInfo32 *in, VkSubpassBeginInfo *out)
6607 {
6608     if (!in) return;
6609
6610     out->sType = in->sType;
6611     out->pNext = in->pNext;
6612     out->contents = in->contents;
6613 }
6614 #endif /* USE_STRUCT_CONVERSION */
6615
6616 #if defined(USE_STRUCT_CONVERSION)
6617 static inline void convert_VkRenderingAttachmentInfo_win32_to_host(const VkRenderingAttachmentInfo32 *in, VkRenderingAttachmentInfo *out)
6618 {
6619     if (!in) return;
6620
6621     out->sType = in->sType;
6622     out->pNext = in->pNext;
6623     out->imageView = in->imageView;
6624     out->imageLayout = in->imageLayout;
6625     out->resolveMode = in->resolveMode;
6626     out->resolveImageView = in->resolveImageView;
6627     out->resolveImageLayout = in->resolveImageLayout;
6628     out->loadOp = in->loadOp;
6629     out->storeOp = in->storeOp;
6630     out->clearValue = in->clearValue;
6631 }
6632 #endif /* USE_STRUCT_CONVERSION */
6633
6634 #if defined(USE_STRUCT_CONVERSION)
6635 static inline const VkRenderingAttachmentInfo *convert_VkRenderingAttachmentInfo_array_win32_to_host(struct conversion_context *ctx, const VkRenderingAttachmentInfo32 *in, uint32_t count)
6636 {
6637     VkRenderingAttachmentInfo *out;
6638     unsigned int i;
6639
6640     if (!in || !count) return NULL;
6641
6642     out = conversion_context_alloc(ctx, count * sizeof(*out));
6643     for (i = 0; i < count; i++)
6644     {
6645         convert_VkRenderingAttachmentInfo_win32_to_host(&in[i], &out[i]);
6646     }
6647
6648     return out;
6649 }
6650 #endif /* USE_STRUCT_CONVERSION */
6651
6652 #if defined(USE_STRUCT_CONVERSION)
6653 static inline void convert_VkRenderingInfo_win32_to_host(struct conversion_context *ctx, const VkRenderingInfo32 *in, VkRenderingInfo *out)
6654 {
6655     const VkBaseInStructure *in_header;
6656     VkBaseOutStructure *out_header = (void *)out;
6657
6658     if (!in) return;
6659
6660     out->sType = in->sType;
6661     out->pNext = NULL;
6662     out->flags = in->flags;
6663     out->renderArea = in->renderArea;
6664     out->layerCount = in->layerCount;
6665     out->viewMask = in->viewMask;
6666     out->colorAttachmentCount = in->colorAttachmentCount;
6667     out->pColorAttachments = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, in->pColorAttachments, in->colorAttachmentCount);
6668     out->pDepthAttachment = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, in->pDepthAttachment, 1);
6669     out->pStencilAttachment = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, in->pStencilAttachment, 1);
6670
6671     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
6672     {
6673         switch (in_header->sType)
6674         {
6675         case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
6676         {
6677             VkDeviceGroupRenderPassBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6678             const VkDeviceGroupRenderPassBeginInfo32 *in_ext = (const VkDeviceGroupRenderPassBeginInfo32 *)in_header;
6679             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
6680             out_ext->pNext = NULL;
6681             out_ext->deviceMask = in_ext->deviceMask;
6682             out_ext->deviceRenderAreaCount = in_ext->deviceRenderAreaCount;
6683             out_ext->pDeviceRenderAreas = in_ext->pDeviceRenderAreas;
6684             out_header->pNext = (void *)out_ext;
6685             out_header = (void *)out_ext;
6686             break;
6687         }
6688         case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
6689         {
6690             VkMultisampledRenderToSingleSampledInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6691             const VkMultisampledRenderToSingleSampledInfoEXT32 *in_ext = (const VkMultisampledRenderToSingleSampledInfoEXT32 *)in_header;
6692             out_ext->sType = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT;
6693             out_ext->pNext = NULL;
6694             out_ext->multisampledRenderToSingleSampledEnable = in_ext->multisampledRenderToSingleSampledEnable;
6695             out_ext->rasterizationSamples = in_ext->rasterizationSamples;
6696             out_header->pNext = (void *)out_ext;
6697             out_header = (void *)out_ext;
6698             break;
6699         }
6700         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
6701         {
6702             VkRenderingFragmentShadingRateAttachmentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6703             const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *in_ext = (const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *)in_header;
6704             out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
6705             out_ext->pNext = NULL;
6706             out_ext->imageView = in_ext->imageView;
6707             out_ext->imageLayout = in_ext->imageLayout;
6708             out_ext->shadingRateAttachmentTexelSize = in_ext->shadingRateAttachmentTexelSize;
6709             out_header->pNext = (void *)out_ext;
6710             out_header = (void *)out_ext;
6711             break;
6712         }
6713         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
6714         {
6715             VkRenderingFragmentDensityMapAttachmentInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6716             const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *in_ext = (const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *)in_header;
6717             out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT;
6718             out_ext->pNext = NULL;
6719             out_ext->imageView = in_ext->imageView;
6720             out_ext->imageLayout = in_ext->imageLayout;
6721             out_header->pNext = (void *)out_ext;
6722             out_header = (void *)out_ext;
6723             break;
6724         }
6725         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
6726         {
6727             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6728             const VkMultiviewPerViewAttributesInfoNVX32 *in_ext = (const VkMultiviewPerViewAttributesInfoNVX32 *)in_header;
6729             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
6730             out_ext->pNext = NULL;
6731             out_ext->perViewAttributes = in_ext->perViewAttributes;
6732             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
6733             out_header->pNext = (void *)out_ext;
6734             out_header = (void *)out_ext;
6735             break;
6736         }
6737         default:
6738             FIXME("Unhandled sType %u.", in_header->sType);
6739             break;
6740         }
6741     }
6742 }
6743 #endif /* USE_STRUCT_CONVERSION */
6744
6745 #if defined(USE_STRUCT_CONVERSION)
6746 static inline void convert_VkImageBlit2_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, VkImageBlit2 *out)
6747 {
6748     const VkBaseInStructure *in_header;
6749     VkBaseOutStructure *out_header = (void *)out;
6750
6751     if (!in) return;
6752
6753     out->sType = in->sType;
6754     out->pNext = NULL;
6755     out->srcSubresource = in->srcSubresource;
6756     memcpy(out->srcOffsets, in->srcOffsets, 2 * sizeof(VkOffset3D));
6757     out->dstSubresource = in->dstSubresource;
6758     memcpy(out->dstOffsets, in->dstOffsets, 2 * sizeof(VkOffset3D));
6759
6760     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
6761     {
6762         switch (in_header->sType)
6763         {
6764         case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
6765         {
6766             VkCopyCommandTransformInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6767             const VkCopyCommandTransformInfoQCOM32 *in_ext = (const VkCopyCommandTransformInfoQCOM32 *)in_header;
6768             out_ext->sType = VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM;
6769             out_ext->pNext = NULL;
6770             out_ext->transform = in_ext->transform;
6771             out_header->pNext = (void *)out_ext;
6772             out_header = (void *)out_ext;
6773             break;
6774         }
6775         default:
6776             FIXME("Unhandled sType %u.", in_header->sType);
6777             break;
6778         }
6779     }
6780 }
6781 #endif /* USE_STRUCT_CONVERSION */
6782
6783 #if defined(USE_STRUCT_CONVERSION)
6784 static inline const VkImageBlit2 *convert_VkImageBlit2_array_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, uint32_t count)
6785 {
6786     VkImageBlit2 *out;
6787     unsigned int i;
6788
6789     if (!in || !count) return NULL;
6790
6791     out = conversion_context_alloc(ctx, count * sizeof(*out));
6792     for (i = 0; i < count; i++)
6793     {
6794         convert_VkImageBlit2_win32_to_host(ctx, &in[i], &out[i]);
6795     }
6796
6797     return out;
6798 }
6799 #endif /* USE_STRUCT_CONVERSION */
6800
6801 #if defined(USE_STRUCT_CONVERSION)
6802 static inline void convert_VkBlitImageInfo2_win32_to_host(struct conversion_context *ctx, const VkBlitImageInfo232 *in, VkBlitImageInfo2 *out)
6803 {
6804     if (!in) return;
6805
6806     out->sType = in->sType;
6807     out->pNext = in->pNext;
6808     out->srcImage = in->srcImage;
6809     out->srcImageLayout = in->srcImageLayout;
6810     out->dstImage = in->dstImage;
6811     out->dstImageLayout = in->dstImageLayout;
6812     out->regionCount = in->regionCount;
6813     out->pRegions = convert_VkImageBlit2_array_win32_to_host(ctx, in->pRegions, in->regionCount);
6814     out->filter = in->filter;
6815 }
6816 #endif /* USE_STRUCT_CONVERSION */
6817
6818 #if defined(USE_STRUCT_CONVERSION)
6819 static inline void convert_VkGeometryTrianglesNV_win32_to_host(const VkGeometryTrianglesNV32 *in, VkGeometryTrianglesNV *out)
6820 {
6821     if (!in) return;
6822
6823     out->sType = in->sType;
6824     out->pNext = in->pNext;
6825     out->vertexData = in->vertexData;
6826     out->vertexOffset = in->vertexOffset;
6827     out->vertexCount = in->vertexCount;
6828     out->vertexStride = in->vertexStride;
6829     out->vertexFormat = in->vertexFormat;
6830     out->indexData = in->indexData;
6831     out->indexOffset = in->indexOffset;
6832     out->indexCount = in->indexCount;
6833     out->indexType = in->indexType;
6834     out->transformData = in->transformData;
6835     out->transformOffset = in->transformOffset;
6836 }
6837 #endif /* USE_STRUCT_CONVERSION */
6838
6839 #if defined(USE_STRUCT_CONVERSION)
6840 static inline void convert_VkGeometryAABBNV_win32_to_host(const VkGeometryAABBNV32 *in, VkGeometryAABBNV *out)
6841 {
6842     if (!in) return;
6843
6844     out->sType = in->sType;
6845     out->pNext = in->pNext;
6846     out->aabbData = in->aabbData;
6847     out->numAABBs = in->numAABBs;
6848     out->stride = in->stride;
6849     out->offset = in->offset;
6850 }
6851 #endif /* USE_STRUCT_CONVERSION */
6852
6853 #if defined(USE_STRUCT_CONVERSION)
6854 static inline void convert_VkGeometryDataNV_win32_to_host(const VkGeometryDataNV32 *in, VkGeometryDataNV *out)
6855 {
6856     if (!in) return;
6857
6858     convert_VkGeometryTrianglesNV_win32_to_host(&in->triangles, &out->triangles);
6859     convert_VkGeometryAABBNV_win32_to_host(&in->aabbs, &out->aabbs);
6860 }
6861 #endif /* USE_STRUCT_CONVERSION */
6862
6863 #if defined(USE_STRUCT_CONVERSION)
6864 static inline void convert_VkGeometryNV_win32_to_host(const VkGeometryNV32 *in, VkGeometryNV *out)
6865 {
6866     if (!in) return;
6867
6868     out->sType = in->sType;
6869     out->pNext = in->pNext;
6870     out->geometryType = in->geometryType;
6871     convert_VkGeometryDataNV_win32_to_host(&in->geometry, &out->geometry);
6872     out->flags = in->flags;
6873 }
6874 #endif /* USE_STRUCT_CONVERSION */
6875
6876 #if defined(USE_STRUCT_CONVERSION)
6877 static inline const VkGeometryNV *convert_VkGeometryNV_array_win32_to_host(struct conversion_context *ctx, const VkGeometryNV32 *in, uint32_t count)
6878 {
6879     VkGeometryNV *out;
6880     unsigned int i;
6881
6882     if (!in || !count) return NULL;
6883
6884     out = conversion_context_alloc(ctx, count * sizeof(*out));
6885     for (i = 0; i < count; i++)
6886     {
6887         convert_VkGeometryNV_win32_to_host(&in[i], &out[i]);
6888     }
6889
6890     return out;
6891 }
6892 #endif /* USE_STRUCT_CONVERSION */
6893
6894 #if defined(USE_STRUCT_CONVERSION)
6895 static inline void convert_VkAccelerationStructureInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureInfoNV32 *in, VkAccelerationStructureInfoNV *out)
6896 {
6897     if (!in) return;
6898
6899     out->sType = in->sType;
6900     out->pNext = in->pNext;
6901     out->type = in->type;
6902     out->flags = in->flags;
6903     out->instanceCount = in->instanceCount;
6904     out->geometryCount = in->geometryCount;
6905     out->pGeometries = convert_VkGeometryNV_array_win32_to_host(ctx, in->pGeometries, in->geometryCount);
6906 }
6907 #endif /* USE_STRUCT_CONVERSION */
6908
6909 #if defined(USE_STRUCT_CONVERSION)
6910 static inline void convert_VkCopyAccelerationStructureInfoKHR_win32_to_host(const VkCopyAccelerationStructureInfoKHR32 *in, VkCopyAccelerationStructureInfoKHR *out)
6911 {
6912     if (!in) return;
6913
6914     out->sType = in->sType;
6915     out->pNext = in->pNext;
6916     out->src = in->src;
6917     out->dst = in->dst;
6918     out->mode = in->mode;
6919 }
6920 #endif /* USE_STRUCT_CONVERSION */
6921
6922 #if defined(USE_STRUCT_CONVERSION)
6923 static inline void convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host(const VkCopyAccelerationStructureToMemoryInfoKHR32 *in, VkCopyAccelerationStructureToMemoryInfoKHR *out)
6924 {
6925     if (!in) return;
6926
6927     out->sType = in->sType;
6928     out->pNext = in->pNext;
6929     out->src = in->src;
6930     out->dst = in->dst;
6931     out->mode = in->mode;
6932 }
6933 #endif /* USE_STRUCT_CONVERSION */
6934
6935 #if defined(USE_STRUCT_CONVERSION)
6936 static inline void convert_VkBufferCopy_win32_to_host(const VkBufferCopy32 *in, VkBufferCopy *out)
6937 {
6938     if (!in) return;
6939
6940     out->srcOffset = in->srcOffset;
6941     out->dstOffset = in->dstOffset;
6942     out->size = in->size;
6943 }
6944 #endif /* USE_STRUCT_CONVERSION */
6945
6946 #if defined(USE_STRUCT_CONVERSION)
6947 static inline const VkBufferCopy *convert_VkBufferCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy32 *in, uint32_t count)
6948 {
6949     VkBufferCopy *out;
6950     unsigned int i;
6951
6952     if (!in || !count) return NULL;
6953
6954     out = conversion_context_alloc(ctx, count * sizeof(*out));
6955     for (i = 0; i < count; i++)
6956     {
6957         convert_VkBufferCopy_win32_to_host(&in[i], &out[i]);
6958     }
6959
6960     return out;
6961 }
6962 #endif /* USE_STRUCT_CONVERSION */
6963
6964 #if defined(USE_STRUCT_CONVERSION)
6965 static inline void convert_VkBufferCopy2_win32_to_host(const VkBufferCopy232 *in, VkBufferCopy2 *out)
6966 {
6967     if (!in) return;
6968
6969     out->sType = in->sType;
6970     out->pNext = in->pNext;
6971     out->srcOffset = in->srcOffset;
6972     out->dstOffset = in->dstOffset;
6973     out->size = in->size;
6974 }
6975 #endif /* USE_STRUCT_CONVERSION */
6976
6977 #if defined(USE_STRUCT_CONVERSION)
6978 static inline const VkBufferCopy2 *convert_VkBufferCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy232 *in, uint32_t count)
6979 {
6980     VkBufferCopy2 *out;
6981     unsigned int i;
6982
6983     if (!in || !count) return NULL;
6984
6985     out = conversion_context_alloc(ctx, count * sizeof(*out));
6986     for (i = 0; i < count; i++)
6987     {
6988         convert_VkBufferCopy2_win32_to_host(&in[i], &out[i]);
6989     }
6990
6991     return out;
6992 }
6993 #endif /* USE_STRUCT_CONVERSION */
6994
6995 #if defined(USE_STRUCT_CONVERSION)
6996 static inline void convert_VkCopyBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferInfo232 *in, VkCopyBufferInfo2 *out)
6997 {
6998     if (!in) return;
6999
7000     out->sType = in->sType;
7001     out->pNext = in->pNext;
7002     out->srcBuffer = in->srcBuffer;
7003     out->dstBuffer = in->dstBuffer;
7004     out->regionCount = in->regionCount;
7005     out->pRegions = convert_VkBufferCopy2_array_win32_to_host(ctx, in->pRegions, in->regionCount);
7006 }
7007 #endif /* USE_STRUCT_CONVERSION */
7008
7009 #if defined(USE_STRUCT_CONVERSION)
7010 static inline void convert_VkBufferImageCopy_win32_to_host(const VkBufferImageCopy32 *in, VkBufferImageCopy *out)
7011 {
7012     if (!in) return;
7013
7014     out->bufferOffset = in->bufferOffset;
7015     out->bufferRowLength = in->bufferRowLength;
7016     out->bufferImageHeight = in->bufferImageHeight;
7017     out->imageSubresource = in->imageSubresource;
7018     out->imageOffset = in->imageOffset;
7019     out->imageExtent = in->imageExtent;
7020 }
7021 #endif /* USE_STRUCT_CONVERSION */
7022
7023 #if defined(USE_STRUCT_CONVERSION)
7024 static inline const VkBufferImageCopy *convert_VkBufferImageCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy32 *in, uint32_t count)
7025 {
7026     VkBufferImageCopy *out;
7027     unsigned int i;
7028
7029     if (!in || !count) return NULL;
7030
7031     out = conversion_context_alloc(ctx, count * sizeof(*out));
7032     for (i = 0; i < count; i++)
7033     {
7034         convert_VkBufferImageCopy_win32_to_host(&in[i], &out[i]);
7035     }
7036
7037     return out;
7038 }
7039 #endif /* USE_STRUCT_CONVERSION */
7040
7041 #if defined(USE_STRUCT_CONVERSION)
7042 static inline void convert_VkBufferImageCopy2_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy232 *in, VkBufferImageCopy2 *out)
7043 {
7044     const VkBaseInStructure *in_header;
7045     VkBaseOutStructure *out_header = (void *)out;
7046
7047     if (!in) return;
7048
7049     out->sType = in->sType;
7050     out->pNext = NULL;
7051     out->bufferOffset = in->bufferOffset;
7052     out->bufferRowLength = in->bufferRowLength;
7053     out->bufferImageHeight = in->bufferImageHeight;
7054     out->imageSubresource = in->imageSubresource;
7055     out->imageOffset = in->imageOffset;
7056     out->imageExtent = in->imageExtent;
7057
7058     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
7059     {
7060         switch (in_header->sType)
7061         {
7062         case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
7063         {
7064             VkCopyCommandTransformInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7065             const VkCopyCommandTransformInfoQCOM32 *in_ext = (const VkCopyCommandTransformInfoQCOM32 *)in_header;
7066             out_ext->sType = VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM;
7067             out_ext->pNext = NULL;
7068             out_ext->transform = in_ext->transform;
7069             out_header->pNext = (void *)out_ext;
7070             out_header = (void *)out_ext;
7071             break;
7072         }
7073         default:
7074             FIXME("Unhandled sType %u.", in_header->sType);
7075             break;
7076         }
7077     }
7078 }
7079 #endif /* USE_STRUCT_CONVERSION */
7080
7081 #if defined(USE_STRUCT_CONVERSION)
7082 static inline const VkBufferImageCopy2 *convert_VkBufferImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy232 *in, uint32_t count)
7083 {
7084     VkBufferImageCopy2 *out;
7085     unsigned int i;
7086
7087     if (!in || !count) return NULL;
7088
7089     out = conversion_context_alloc(ctx, count * sizeof(*out));
7090     for (i = 0; i < count; i++)
7091     {
7092         convert_VkBufferImageCopy2_win32_to_host(ctx, &in[i], &out[i]);
7093     }
7094
7095     return out;
7096 }
7097 #endif /* USE_STRUCT_CONVERSION */
7098
7099 #if defined(USE_STRUCT_CONVERSION)
7100 static inline void convert_VkCopyBufferToImageInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferToImageInfo232 *in, VkCopyBufferToImageInfo2 *out)
7101 {
7102     if (!in) return;
7103
7104     out->sType = in->sType;
7105     out->pNext = in->pNext;
7106     out->srcBuffer = in->srcBuffer;
7107     out->dstImage = in->dstImage;
7108     out->dstImageLayout = in->dstImageLayout;
7109     out->regionCount = in->regionCount;
7110     out->pRegions = convert_VkBufferImageCopy2_array_win32_to_host(ctx, in->pRegions, in->regionCount);
7111 }
7112 #endif /* USE_STRUCT_CONVERSION */
7113
7114 #if defined(USE_STRUCT_CONVERSION)
7115 static inline void convert_VkImageCopy2_win32_to_host(const VkImageCopy232 *in, VkImageCopy2 *out)
7116 {
7117     if (!in) return;
7118
7119     out->sType = in->sType;
7120     out->pNext = in->pNext;
7121     out->srcSubresource = in->srcSubresource;
7122     out->srcOffset = in->srcOffset;
7123     out->dstSubresource = in->dstSubresource;
7124     out->dstOffset = in->dstOffset;
7125     out->extent = in->extent;
7126 }
7127 #endif /* USE_STRUCT_CONVERSION */
7128
7129 #if defined(USE_STRUCT_CONVERSION)
7130 static inline const VkImageCopy2 *convert_VkImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkImageCopy232 *in, uint32_t count)
7131 {
7132     VkImageCopy2 *out;
7133     unsigned int i;
7134
7135     if (!in || !count) return NULL;
7136
7137     out = conversion_context_alloc(ctx, count * sizeof(*out));
7138     for (i = 0; i < count; i++)
7139     {
7140         convert_VkImageCopy2_win32_to_host(&in[i], &out[i]);
7141     }
7142
7143     return out;
7144 }
7145 #endif /* USE_STRUCT_CONVERSION */
7146
7147 #if defined(USE_STRUCT_CONVERSION)
7148 static inline void convert_VkCopyImageInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyImageInfo232 *in, VkCopyImageInfo2 *out)
7149 {
7150     if (!in) return;
7151
7152     out->sType = in->sType;
7153     out->pNext = in->pNext;
7154     out->srcImage = in->srcImage;
7155     out->srcImageLayout = in->srcImageLayout;
7156     out->dstImage = in->dstImage;
7157     out->dstImageLayout = in->dstImageLayout;
7158     out->regionCount = in->regionCount;
7159     out->pRegions = convert_VkImageCopy2_array_win32_to_host(ctx, in->pRegions, in->regionCount);
7160 }
7161 #endif /* USE_STRUCT_CONVERSION */
7162
7163 #if defined(USE_STRUCT_CONVERSION)
7164 static inline void convert_VkCopyImageToBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyImageToBufferInfo232 *in, VkCopyImageToBufferInfo2 *out)
7165 {
7166     if (!in) return;
7167
7168     out->sType = in->sType;
7169     out->pNext = in->pNext;
7170     out->srcImage = in->srcImage;
7171     out->srcImageLayout = in->srcImageLayout;
7172     out->dstBuffer = in->dstBuffer;
7173     out->regionCount = in->regionCount;
7174     out->pRegions = convert_VkBufferImageCopy2_array_win32_to_host(ctx, in->pRegions, in->regionCount);
7175 }
7176 #endif /* USE_STRUCT_CONVERSION */
7177
7178 #if defined(USE_STRUCT_CONVERSION)
7179 static inline void convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host(const VkCopyMemoryToAccelerationStructureInfoKHR32 *in, VkCopyMemoryToAccelerationStructureInfoKHR *out)
7180 {
7181     if (!in) return;
7182
7183     out->sType = in->sType;
7184     out->pNext = in->pNext;
7185     out->src = in->src;
7186     out->dst = in->dst;
7187     out->mode = in->mode;
7188 }
7189 #endif /* USE_STRUCT_CONVERSION */
7190
7191 #if defined(USE_STRUCT_CONVERSION)
7192 static inline void convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(const VkCopyMemoryToMicromapInfoEXT32 *in, VkCopyMemoryToMicromapInfoEXT *out)
7193 {
7194     if (!in) return;
7195
7196     out->sType = in->sType;
7197     out->pNext = in->pNext;
7198     out->src = in->src;
7199     out->dst = in->dst;
7200     out->mode = in->mode;
7201 }
7202 #endif /* USE_STRUCT_CONVERSION */
7203
7204 #if defined(USE_STRUCT_CONVERSION)
7205 static inline void convert_VkCopyMicromapInfoEXT_win32_to_host(const VkCopyMicromapInfoEXT32 *in, VkCopyMicromapInfoEXT *out)
7206 {
7207     if (!in) return;
7208
7209     out->sType = in->sType;
7210     out->pNext = in->pNext;
7211     out->src = in->src;
7212     out->dst = in->dst;
7213     out->mode = in->mode;
7214 }
7215 #endif /* USE_STRUCT_CONVERSION */
7216
7217 #if defined(USE_STRUCT_CONVERSION)
7218 static inline void convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(const VkCopyMicromapToMemoryInfoEXT32 *in, VkCopyMicromapToMemoryInfoEXT *out)
7219 {
7220     if (!in) return;
7221
7222     out->sType = in->sType;
7223     out->pNext = in->pNext;
7224     out->src = in->src;
7225     out->dst = in->dst;
7226     out->mode = in->mode;
7227 }
7228 #endif /* USE_STRUCT_CONVERSION */
7229
7230 #if defined(USE_STRUCT_CONVERSION)
7231 static inline void convert_VkCuLaunchInfoNVX_win32_to_host(const VkCuLaunchInfoNVX32 *in, VkCuLaunchInfoNVX *out)
7232 {
7233     if (!in) return;
7234
7235     out->sType = in->sType;
7236     out->pNext = in->pNext;
7237     out->function = in->function;
7238     out->gridDimX = in->gridDimX;
7239     out->gridDimY = in->gridDimY;
7240     out->gridDimZ = in->gridDimZ;
7241     out->blockDimX = in->blockDimX;
7242     out->blockDimY = in->blockDimY;
7243     out->blockDimZ = in->blockDimZ;
7244     out->sharedMemBytes = in->sharedMemBytes;
7245     out->paramCount = in->paramCount;
7246     out->pParams = in->pParams;
7247     out->extraCount = in->extraCount;
7248     out->pExtras = in->pExtras;
7249 }
7250 #endif /* USE_STRUCT_CONVERSION */
7251
7252 #if defined(USE_STRUCT_CONVERSION)
7253 static inline void convert_VkDebugMarkerMarkerInfoEXT_win32_to_host(const VkDebugMarkerMarkerInfoEXT32 *in, VkDebugMarkerMarkerInfoEXT *out)
7254 {
7255     if (!in) return;
7256
7257     out->sType = in->sType;
7258     out->pNext = in->pNext;
7259     out->pMarkerName = in->pMarkerName;
7260     memcpy(out->color, in->color, 4 * sizeof(float));
7261 }
7262 #endif /* USE_STRUCT_CONVERSION */
7263
7264 #if defined(USE_STRUCT_CONVERSION)
7265 static inline void convert_VkDecompressMemoryRegionNV_win32_to_host(const VkDecompressMemoryRegionNV32 *in, VkDecompressMemoryRegionNV *out)
7266 {
7267     if (!in) return;
7268
7269     out->srcAddress = in->srcAddress;
7270     out->dstAddress = in->dstAddress;
7271     out->compressedSize = in->compressedSize;
7272     out->decompressedSize = in->decompressedSize;
7273     out->decompressionMethod = in->decompressionMethod;
7274 }
7275 #endif /* USE_STRUCT_CONVERSION */
7276
7277 #if defined(USE_STRUCT_CONVERSION)
7278 static inline const VkDecompressMemoryRegionNV *convert_VkDecompressMemoryRegionNV_array_win32_to_host(struct conversion_context *ctx, const VkDecompressMemoryRegionNV32 *in, uint32_t count)
7279 {
7280     VkDecompressMemoryRegionNV *out;
7281     unsigned int i;
7282
7283     if (!in || !count) return NULL;
7284
7285     out = conversion_context_alloc(ctx, count * sizeof(*out));
7286     for (i = 0; i < count; i++)
7287     {
7288         convert_VkDecompressMemoryRegionNV_win32_to_host(&in[i], &out[i]);
7289     }
7290
7291     return out;
7292 }
7293 #endif /* USE_STRUCT_CONVERSION */
7294
7295 #if defined(USE_STRUCT_CONVERSION)
7296 static inline void convert_VkSubpassEndInfo_win32_to_host(struct conversion_context *ctx, const VkSubpassEndInfo32 *in, VkSubpassEndInfo *out)
7297 {
7298     const VkBaseInStructure *in_header;
7299     VkBaseOutStructure *out_header = (void *)out;
7300
7301     if (!in) return;
7302
7303     out->sType = in->sType;
7304     out->pNext = NULL;
7305
7306     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
7307     {
7308         switch (in_header->sType)
7309         {
7310         case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM:
7311         {
7312             VkSubpassFragmentDensityMapOffsetEndInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7313             const VkSubpassFragmentDensityMapOffsetEndInfoQCOM32 *in_ext = (const VkSubpassFragmentDensityMapOffsetEndInfoQCOM32 *)in_header;
7314             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM;
7315             out_ext->pNext = NULL;
7316             out_ext->fragmentDensityOffsetCount = in_ext->fragmentDensityOffsetCount;
7317             out_ext->pFragmentDensityOffsets = in_ext->pFragmentDensityOffsets;
7318             out_header->pNext = (void *)out_ext;
7319             out_header = (void *)out_ext;
7320             break;
7321         }
7322         default:
7323             FIXME("Unhandled sType %u.", in_header->sType);
7324             break;
7325         }
7326     }
7327 }
7328 #endif /* USE_STRUCT_CONVERSION */
7329
7330 #if !defined(USE_STRUCT_CONVERSION)
7331 static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win64_to_host(struct conversion_context *ctx, const VkCommandBuffer *in, uint32_t count)
7332 {
7333     VkCommandBuffer *out;
7334     unsigned int i;
7335
7336     if (!in || !count) return NULL;
7337
7338     out = conversion_context_alloc(ctx, count * sizeof(*out));
7339     for (i = 0; i < count; i++)
7340     {
7341         out[i] = wine_cmd_buffer_from_handle(in[i])->command_buffer;
7342     }
7343
7344     return out;
7345 }
7346 #endif /* USE_STRUCT_CONVERSION */
7347
7348 #if defined(USE_STRUCT_CONVERSION)
7349 static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_host(struct conversion_context *ctx, const VkCommandBuffer *in, uint32_t count)
7350 {
7351     VkCommandBuffer *out;
7352     unsigned int i;
7353
7354     if (!in || !count) return NULL;
7355
7356     out = conversion_context_alloc(ctx, count * sizeof(*out));
7357     for (i = 0; i < count; i++)
7358     {
7359         out[i] = wine_cmd_buffer_from_handle(in[i])->command_buffer;
7360     }
7361
7362     return out;
7363 }
7364 #endif /* USE_STRUCT_CONVERSION */
7365
7366 #if defined(USE_STRUCT_CONVERSION)
7367 static inline void convert_VkIndirectCommandsStreamNV_win32_to_host(const VkIndirectCommandsStreamNV32 *in, VkIndirectCommandsStreamNV *out)
7368 {
7369     if (!in) return;
7370
7371     out->buffer = in->buffer;
7372     out->offset = in->offset;
7373 }
7374 #endif /* USE_STRUCT_CONVERSION */
7375
7376 #if defined(USE_STRUCT_CONVERSION)
7377 static inline const VkIndirectCommandsStreamNV *convert_VkIndirectCommandsStreamNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsStreamNV32 *in, uint32_t count)
7378 {
7379     VkIndirectCommandsStreamNV *out;
7380     unsigned int i;
7381
7382     if (!in || !count) return NULL;
7383
7384     out = conversion_context_alloc(ctx, count * sizeof(*out));
7385     for (i = 0; i < count; i++)
7386     {
7387         convert_VkIndirectCommandsStreamNV_win32_to_host(&in[i], &out[i]);
7388     }
7389
7390     return out;
7391 }
7392 #endif /* USE_STRUCT_CONVERSION */
7393
7394 #if defined(USE_STRUCT_CONVERSION)
7395 static inline void convert_VkGeneratedCommandsInfoNV_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsInfoNV32 *in, VkGeneratedCommandsInfoNV *out)
7396 {
7397     if (!in) return;
7398
7399     out->sType = in->sType;
7400     out->pNext = in->pNext;
7401     out->pipelineBindPoint = in->pipelineBindPoint;
7402     out->pipeline = in->pipeline;
7403     out->indirectCommandsLayout = in->indirectCommandsLayout;
7404     out->streamCount = in->streamCount;
7405     out->pStreams = convert_VkIndirectCommandsStreamNV_array_win32_to_host(ctx, in->pStreams, in->streamCount);
7406     out->sequencesCount = in->sequencesCount;
7407     out->preprocessBuffer = in->preprocessBuffer;
7408     out->preprocessOffset = in->preprocessOffset;
7409     out->preprocessSize = in->preprocessSize;
7410     out->sequencesCountBuffer = in->sequencesCountBuffer;
7411     out->sequencesCountOffset = in->sequencesCountOffset;
7412     out->sequencesIndexBuffer = in->sequencesIndexBuffer;
7413     out->sequencesIndexOffset = in->sequencesIndexOffset;
7414 }
7415 #endif /* USE_STRUCT_CONVERSION */
7416
7417 #if defined(USE_STRUCT_CONVERSION)
7418 static inline void convert_VkOpticalFlowExecuteInfoNV_win32_to_host(const VkOpticalFlowExecuteInfoNV32 *in, VkOpticalFlowExecuteInfoNV *out)
7419 {
7420     if (!in) return;
7421
7422     out->sType = in->sType;
7423     out->pNext = in->pNext;
7424     out->flags = in->flags;
7425     out->regionCount = in->regionCount;
7426     out->pRegions = in->pRegions;
7427 }
7428 #endif /* USE_STRUCT_CONVERSION */
7429
7430 #if defined(USE_STRUCT_CONVERSION)
7431 static inline void convert_VkMemoryBarrier_win32_to_host(const VkMemoryBarrier32 *in, VkMemoryBarrier *out)
7432 {
7433     if (!in) return;
7434
7435     out->sType = in->sType;
7436     out->pNext = in->pNext;
7437     out->srcAccessMask = in->srcAccessMask;
7438     out->dstAccessMask = in->dstAccessMask;
7439 }
7440 #endif /* USE_STRUCT_CONVERSION */
7441
7442 #if defined(USE_STRUCT_CONVERSION)
7443 static inline const VkMemoryBarrier *convert_VkMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkMemoryBarrier32 *in, uint32_t count)
7444 {
7445     VkMemoryBarrier *out;
7446     unsigned int i;
7447
7448     if (!in || !count) return NULL;
7449
7450     out = conversion_context_alloc(ctx, count * sizeof(*out));
7451     for (i = 0; i < count; i++)
7452     {
7453         convert_VkMemoryBarrier_win32_to_host(&in[i], &out[i]);
7454     }
7455
7456     return out;
7457 }
7458 #endif /* USE_STRUCT_CONVERSION */
7459
7460 #if defined(USE_STRUCT_CONVERSION)
7461 static inline void convert_VkBufferMemoryBarrier_win32_to_host(const VkBufferMemoryBarrier32 *in, VkBufferMemoryBarrier *out)
7462 {
7463     if (!in) return;
7464
7465     out->sType = in->sType;
7466     out->pNext = in->pNext;
7467     out->srcAccessMask = in->srcAccessMask;
7468     out->dstAccessMask = in->dstAccessMask;
7469     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
7470     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
7471     out->buffer = in->buffer;
7472     out->offset = in->offset;
7473     out->size = in->size;
7474 }
7475 #endif /* USE_STRUCT_CONVERSION */
7476
7477 #if defined(USE_STRUCT_CONVERSION)
7478 static inline const VkBufferMemoryBarrier *convert_VkBufferMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier32 *in, uint32_t count)
7479 {
7480     VkBufferMemoryBarrier *out;
7481     unsigned int i;
7482
7483     if (!in || !count) return NULL;
7484
7485     out = conversion_context_alloc(ctx, count * sizeof(*out));
7486     for (i = 0; i < count; i++)
7487     {
7488         convert_VkBufferMemoryBarrier_win32_to_host(&in[i], &out[i]);
7489     }
7490
7491     return out;
7492 }
7493 #endif /* USE_STRUCT_CONVERSION */
7494
7495 #if defined(USE_STRUCT_CONVERSION)
7496 static inline void convert_VkImageMemoryBarrier_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier32 *in, VkImageMemoryBarrier *out)
7497 {
7498     const VkBaseInStructure *in_header;
7499     VkBaseOutStructure *out_header = (void *)out;
7500
7501     if (!in) return;
7502
7503     out->sType = in->sType;
7504     out->pNext = NULL;
7505     out->srcAccessMask = in->srcAccessMask;
7506     out->dstAccessMask = in->dstAccessMask;
7507     out->oldLayout = in->oldLayout;
7508     out->newLayout = in->newLayout;
7509     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
7510     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
7511     out->image = in->image;
7512     out->subresourceRange = in->subresourceRange;
7513
7514     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
7515     {
7516         switch (in_header->sType)
7517         {
7518         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
7519         {
7520             VkSampleLocationsInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7521             const VkSampleLocationsInfoEXT32 *in_ext = (const VkSampleLocationsInfoEXT32 *)in_header;
7522             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT;
7523             out_ext->pNext = NULL;
7524             out_ext->sampleLocationsPerPixel = in_ext->sampleLocationsPerPixel;
7525             out_ext->sampleLocationGridSize = in_ext->sampleLocationGridSize;
7526             out_ext->sampleLocationsCount = in_ext->sampleLocationsCount;
7527             out_ext->pSampleLocations = in_ext->pSampleLocations;
7528             out_header->pNext = (void *)out_ext;
7529             out_header = (void *)out_ext;
7530             break;
7531         }
7532         default:
7533             FIXME("Unhandled sType %u.", in_header->sType);
7534             break;
7535         }
7536     }
7537 }
7538 #endif /* USE_STRUCT_CONVERSION */
7539
7540 #if defined(USE_STRUCT_CONVERSION)
7541 static inline const VkImageMemoryBarrier *convert_VkImageMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier32 *in, uint32_t count)
7542 {
7543     VkImageMemoryBarrier *out;
7544     unsigned int i;
7545
7546     if (!in || !count) return NULL;
7547
7548     out = conversion_context_alloc(ctx, count * sizeof(*out));
7549     for (i = 0; i < count; i++)
7550     {
7551         convert_VkImageMemoryBarrier_win32_to_host(ctx, &in[i], &out[i]);
7552     }
7553
7554     return out;
7555 }
7556 #endif /* USE_STRUCT_CONVERSION */
7557
7558 #if defined(USE_STRUCT_CONVERSION)
7559 static inline void convert_VkMemoryBarrier2_win32_to_host(const VkMemoryBarrier232 *in, VkMemoryBarrier2 *out)
7560 {
7561     if (!in) return;
7562
7563     out->sType = in->sType;
7564     out->pNext = in->pNext;
7565     out->srcStageMask = in->srcStageMask;
7566     out->srcAccessMask = in->srcAccessMask;
7567     out->dstStageMask = in->dstStageMask;
7568     out->dstAccessMask = in->dstAccessMask;
7569 }
7570 #endif /* USE_STRUCT_CONVERSION */
7571
7572 #if defined(USE_STRUCT_CONVERSION)
7573 static inline const VkMemoryBarrier2 *convert_VkMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkMemoryBarrier232 *in, uint32_t count)
7574 {
7575     VkMemoryBarrier2 *out;
7576     unsigned int i;
7577
7578     if (!in || !count) return NULL;
7579
7580     out = conversion_context_alloc(ctx, count * sizeof(*out));
7581     for (i = 0; i < count; i++)
7582     {
7583         convert_VkMemoryBarrier2_win32_to_host(&in[i], &out[i]);
7584     }
7585
7586     return out;
7587 }
7588 #endif /* USE_STRUCT_CONVERSION */
7589
7590 #if defined(USE_STRUCT_CONVERSION)
7591 static inline void convert_VkBufferMemoryBarrier2_win32_to_host(const VkBufferMemoryBarrier232 *in, VkBufferMemoryBarrier2 *out)
7592 {
7593     if (!in) return;
7594
7595     out->sType = in->sType;
7596     out->pNext = in->pNext;
7597     out->srcStageMask = in->srcStageMask;
7598     out->srcAccessMask = in->srcAccessMask;
7599     out->dstStageMask = in->dstStageMask;
7600     out->dstAccessMask = in->dstAccessMask;
7601     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
7602     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
7603     out->buffer = in->buffer;
7604     out->offset = in->offset;
7605     out->size = in->size;
7606 }
7607 #endif /* USE_STRUCT_CONVERSION */
7608
7609 #if defined(USE_STRUCT_CONVERSION)
7610 static inline const VkBufferMemoryBarrier2 *convert_VkBufferMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier232 *in, uint32_t count)
7611 {
7612     VkBufferMemoryBarrier2 *out;
7613     unsigned int i;
7614
7615     if (!in || !count) return NULL;
7616
7617     out = conversion_context_alloc(ctx, count * sizeof(*out));
7618     for (i = 0; i < count; i++)
7619     {
7620         convert_VkBufferMemoryBarrier2_win32_to_host(&in[i], &out[i]);
7621     }
7622
7623     return out;
7624 }
7625 #endif /* USE_STRUCT_CONVERSION */
7626
7627 #if defined(USE_STRUCT_CONVERSION)
7628 static inline void convert_VkImageMemoryBarrier2_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier232 *in, VkImageMemoryBarrier2 *out)
7629 {
7630     const VkBaseInStructure *in_header;
7631     VkBaseOutStructure *out_header = (void *)out;
7632
7633     if (!in) return;
7634
7635     out->sType = in->sType;
7636     out->pNext = NULL;
7637     out->srcStageMask = in->srcStageMask;
7638     out->srcAccessMask = in->srcAccessMask;
7639     out->dstStageMask = in->dstStageMask;
7640     out->dstAccessMask = in->dstAccessMask;
7641     out->oldLayout = in->oldLayout;
7642     out->newLayout = in->newLayout;
7643     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
7644     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
7645     out->image = in->image;
7646     out->subresourceRange = in->subresourceRange;
7647
7648     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
7649     {
7650         switch (in_header->sType)
7651         {
7652         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
7653         {
7654             VkSampleLocationsInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7655             const VkSampleLocationsInfoEXT32 *in_ext = (const VkSampleLocationsInfoEXT32 *)in_header;
7656             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT;
7657             out_ext->pNext = NULL;
7658             out_ext->sampleLocationsPerPixel = in_ext->sampleLocationsPerPixel;
7659             out_ext->sampleLocationGridSize = in_ext->sampleLocationGridSize;
7660             out_ext->sampleLocationsCount = in_ext->sampleLocationsCount;
7661             out_ext->pSampleLocations = in_ext->pSampleLocations;
7662             out_header->pNext = (void *)out_ext;
7663             out_header = (void *)out_ext;
7664             break;
7665         }
7666         default:
7667             FIXME("Unhandled sType %u.", in_header->sType);
7668             break;
7669         }
7670     }
7671 }
7672 #endif /* USE_STRUCT_CONVERSION */
7673
7674 #if defined(USE_STRUCT_CONVERSION)
7675 static inline const VkImageMemoryBarrier2 *convert_VkImageMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier232 *in, uint32_t count)
7676 {
7677     VkImageMemoryBarrier2 *out;
7678     unsigned int i;
7679
7680     if (!in || !count) return NULL;
7681
7682     out = conversion_context_alloc(ctx, count * sizeof(*out));
7683     for (i = 0; i < count; i++)
7684     {
7685         convert_VkImageMemoryBarrier2_win32_to_host(ctx, &in[i], &out[i]);
7686     }
7687
7688     return out;
7689 }
7690 #endif /* USE_STRUCT_CONVERSION */
7691
7692 #if defined(USE_STRUCT_CONVERSION)
7693 static inline void convert_VkDependencyInfo_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, VkDependencyInfo *out)
7694 {
7695     if (!in) return;
7696
7697     out->sType = in->sType;
7698     out->pNext = in->pNext;
7699     out->dependencyFlags = in->dependencyFlags;
7700     out->memoryBarrierCount = in->memoryBarrierCount;
7701     out->pMemoryBarriers = convert_VkMemoryBarrier2_array_win32_to_host(ctx, in->pMemoryBarriers, in->memoryBarrierCount);
7702     out->bufferMemoryBarrierCount = in->bufferMemoryBarrierCount;
7703     out->pBufferMemoryBarriers = convert_VkBufferMemoryBarrier2_array_win32_to_host(ctx, in->pBufferMemoryBarriers, in->bufferMemoryBarrierCount);
7704     out->imageMemoryBarrierCount = in->imageMemoryBarrierCount;
7705     out->pImageMemoryBarriers = convert_VkImageMemoryBarrier2_array_win32_to_host(ctx, in->pImageMemoryBarriers, in->imageMemoryBarrierCount);
7706 }
7707 #endif /* USE_STRUCT_CONVERSION */
7708
7709 #if defined(USE_STRUCT_CONVERSION)
7710 static inline void convert_VkDescriptorImageInfo_win32_to_host(const VkDescriptorImageInfo32 *in, VkDescriptorImageInfo *out)
7711 {
7712     if (!in) return;
7713
7714     out->sampler = in->sampler;
7715     out->imageView = in->imageView;
7716     out->imageLayout = in->imageLayout;
7717 }
7718 #endif /* USE_STRUCT_CONVERSION */
7719
7720 #if defined(USE_STRUCT_CONVERSION)
7721 static inline const VkDescriptorImageInfo *convert_VkDescriptorImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorImageInfo32 *in, uint32_t count)
7722 {
7723     VkDescriptorImageInfo *out;
7724     unsigned int i;
7725
7726     if (!in || !count) return NULL;
7727
7728     out = conversion_context_alloc(ctx, count * sizeof(*out));
7729     for (i = 0; i < count; i++)
7730     {
7731         convert_VkDescriptorImageInfo_win32_to_host(&in[i], &out[i]);
7732     }
7733
7734     return out;
7735 }
7736 #endif /* USE_STRUCT_CONVERSION */
7737
7738 #if defined(USE_STRUCT_CONVERSION)
7739 static inline void convert_VkDescriptorBufferInfo_win32_to_host(const VkDescriptorBufferInfo32 *in, VkDescriptorBufferInfo *out)
7740 {
7741     if (!in) return;
7742
7743     out->buffer = in->buffer;
7744     out->offset = in->offset;
7745     out->range = in->range;
7746 }
7747 #endif /* USE_STRUCT_CONVERSION */
7748
7749 #if defined(USE_STRUCT_CONVERSION)
7750 static inline const VkDescriptorBufferInfo *convert_VkDescriptorBufferInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferInfo32 *in, uint32_t count)
7751 {
7752     VkDescriptorBufferInfo *out;
7753     unsigned int i;
7754
7755     if (!in || !count) return NULL;
7756
7757     out = conversion_context_alloc(ctx, count * sizeof(*out));
7758     for (i = 0; i < count; i++)
7759     {
7760         convert_VkDescriptorBufferInfo_win32_to_host(&in[i], &out[i]);
7761     }
7762
7763     return out;
7764 }
7765 #endif /* USE_STRUCT_CONVERSION */
7766
7767 #if defined(USE_STRUCT_CONVERSION)
7768 static inline void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, VkWriteDescriptorSet *out)
7769 {
7770     const VkBaseInStructure *in_header;
7771     VkBaseOutStructure *out_header = (void *)out;
7772
7773     if (!in) return;
7774
7775     out->sType = in->sType;
7776     out->pNext = NULL;
7777     out->dstSet = in->dstSet;
7778     out->dstBinding = in->dstBinding;
7779     out->dstArrayElement = in->dstArrayElement;
7780     out->descriptorCount = in->descriptorCount;
7781     out->descriptorType = in->descriptorType;
7782     out->pImageInfo = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, in->pImageInfo, in->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || in->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER || in->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE || in->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE || in->descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT || in->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM || in->descriptorType == VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM ? in->descriptorCount : 0);
7783     out->pBufferInfo = convert_VkDescriptorBufferInfo_array_win32_to_host(ctx, in->pBufferInfo, in->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER || in->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER || in->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC || in->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC ? in->descriptorCount : 0);
7784     out->pTexelBufferView = in->pTexelBufferView;
7785
7786     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
7787     {
7788         switch (in_header->sType)
7789         {
7790         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
7791         {
7792             VkWriteDescriptorSetInlineUniformBlock *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7793             const VkWriteDescriptorSetInlineUniformBlock32 *in_ext = (const VkWriteDescriptorSetInlineUniformBlock32 *)in_header;
7794             out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK;
7795             out_ext->pNext = NULL;
7796             out_ext->dataSize = in_ext->dataSize;
7797             out_ext->pData = in_ext->pData;
7798             out_header->pNext = (void *)out_ext;
7799             out_header = (void *)out_ext;
7800             break;
7801         }
7802         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
7803         {
7804             VkWriteDescriptorSetAccelerationStructureKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7805             const VkWriteDescriptorSetAccelerationStructureKHR32 *in_ext = (const VkWriteDescriptorSetAccelerationStructureKHR32 *)in_header;
7806             out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR;
7807             out_ext->pNext = NULL;
7808             out_ext->accelerationStructureCount = in_ext->accelerationStructureCount;
7809             out_ext->pAccelerationStructures = in_ext->pAccelerationStructures;
7810             out_header->pNext = (void *)out_ext;
7811             out_header = (void *)out_ext;
7812             break;
7813         }
7814         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
7815         {
7816             VkWriteDescriptorSetAccelerationStructureNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7817             const VkWriteDescriptorSetAccelerationStructureNV32 *in_ext = (const VkWriteDescriptorSetAccelerationStructureNV32 *)in_header;
7818             out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV;
7819             out_ext->pNext = NULL;
7820             out_ext->accelerationStructureCount = in_ext->accelerationStructureCount;
7821             out_ext->pAccelerationStructures = in_ext->pAccelerationStructures;
7822             out_header->pNext = (void *)out_ext;
7823             out_header = (void *)out_ext;
7824             break;
7825         }
7826         default:
7827             FIXME("Unhandled sType %u.", in_header->sType);
7828             break;
7829         }
7830     }
7831 }
7832 #endif /* USE_STRUCT_CONVERSION */
7833
7834 #if defined(USE_STRUCT_CONVERSION)
7835 static inline const VkWriteDescriptorSet *convert_VkWriteDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, uint32_t count)
7836 {
7837     VkWriteDescriptorSet *out;
7838     unsigned int i;
7839
7840     if (!in || !count) return NULL;
7841
7842     out = conversion_context_alloc(ctx, count * sizeof(*out));
7843     for (i = 0; i < count; i++)
7844     {
7845         convert_VkWriteDescriptorSet_win32_to_host(ctx, &in[i], &out[i]);
7846     }
7847
7848     return out;
7849 }
7850 #endif /* USE_STRUCT_CONVERSION */
7851
7852 #if defined(USE_STRUCT_CONVERSION)
7853 static inline void convert_VkImageResolve2_win32_to_host(const VkImageResolve232 *in, VkImageResolve2 *out)
7854 {
7855     if (!in) return;
7856
7857     out->sType = in->sType;
7858     out->pNext = in->pNext;
7859     out->srcSubresource = in->srcSubresource;
7860     out->srcOffset = in->srcOffset;
7861     out->dstSubresource = in->dstSubresource;
7862     out->dstOffset = in->dstOffset;
7863     out->extent = in->extent;
7864 }
7865 #endif /* USE_STRUCT_CONVERSION */
7866
7867 #if defined(USE_STRUCT_CONVERSION)
7868 static inline const VkImageResolve2 *convert_VkImageResolve2_array_win32_to_host(struct conversion_context *ctx, const VkImageResolve232 *in, uint32_t count)
7869 {
7870     VkImageResolve2 *out;
7871     unsigned int i;
7872
7873     if (!in || !count) return NULL;
7874
7875     out = conversion_context_alloc(ctx, count * sizeof(*out));
7876     for (i = 0; i < count; i++)
7877     {
7878         convert_VkImageResolve2_win32_to_host(&in[i], &out[i]);
7879     }
7880
7881     return out;
7882 }
7883 #endif /* USE_STRUCT_CONVERSION */
7884
7885 #if defined(USE_STRUCT_CONVERSION)
7886 static inline void convert_VkResolveImageInfo2_win32_to_host(struct conversion_context *ctx, const VkResolveImageInfo232 *in, VkResolveImageInfo2 *out)
7887 {
7888     if (!in) return;
7889
7890     out->sType = in->sType;
7891     out->pNext = in->pNext;
7892     out->srcImage = in->srcImage;
7893     out->srcImageLayout = in->srcImageLayout;
7894     out->dstImage = in->dstImage;
7895     out->dstImageLayout = in->dstImageLayout;
7896     out->regionCount = in->regionCount;
7897     out->pRegions = convert_VkImageResolve2_array_win32_to_host(ctx, in->pRegions, in->regionCount);
7898 }
7899 #endif /* USE_STRUCT_CONVERSION */
7900
7901 #if defined(USE_STRUCT_CONVERSION)
7902 static inline void convert_VkPerformanceMarkerInfoINTEL_win32_to_host(const VkPerformanceMarkerInfoINTEL32 *in, VkPerformanceMarkerInfoINTEL *out)
7903 {
7904     if (!in) return;
7905
7906     out->sType = in->sType;
7907     out->pNext = in->pNext;
7908     out->marker = in->marker;
7909 }
7910 #endif /* USE_STRUCT_CONVERSION */
7911
7912 #if defined(USE_STRUCT_CONVERSION)
7913 static inline void convert_VkPerformanceOverrideInfoINTEL_win32_to_host(const VkPerformanceOverrideInfoINTEL32 *in, VkPerformanceOverrideInfoINTEL *out)
7914 {
7915     if (!in) return;
7916
7917     out->sType = in->sType;
7918     out->pNext = in->pNext;
7919     out->type = in->type;
7920     out->enable = in->enable;
7921     out->parameter = in->parameter;
7922 }
7923 #endif /* USE_STRUCT_CONVERSION */
7924
7925 #if defined(USE_STRUCT_CONVERSION)
7926 static inline void convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host(const VkPerformanceStreamMarkerInfoINTEL32 *in, VkPerformanceStreamMarkerInfoINTEL *out)
7927 {
7928     if (!in) return;
7929
7930     out->sType = in->sType;
7931     out->pNext = in->pNext;
7932     out->marker = in->marker;
7933 }
7934 #endif /* USE_STRUCT_CONVERSION */
7935
7936 #if defined(USE_STRUCT_CONVERSION)
7937 static inline void convert_VkVertexInputBindingDescription2EXT_win32_to_host(const VkVertexInputBindingDescription2EXT32 *in, VkVertexInputBindingDescription2EXT *out)
7938 {
7939     if (!in) return;
7940
7941     out->sType = in->sType;
7942     out->pNext = in->pNext;
7943     out->binding = in->binding;
7944     out->stride = in->stride;
7945     out->inputRate = in->inputRate;
7946     out->divisor = in->divisor;
7947 }
7948 #endif /* USE_STRUCT_CONVERSION */
7949
7950 #if defined(USE_STRUCT_CONVERSION)
7951 static inline const VkVertexInputBindingDescription2EXT *convert_VkVertexInputBindingDescription2EXT_array_win32_to_host(struct conversion_context *ctx, const VkVertexInputBindingDescription2EXT32 *in, uint32_t count)
7952 {
7953     VkVertexInputBindingDescription2EXT *out;
7954     unsigned int i;
7955
7956     if (!in || !count) return NULL;
7957
7958     out = conversion_context_alloc(ctx, count * sizeof(*out));
7959     for (i = 0; i < count; i++)
7960     {
7961         convert_VkVertexInputBindingDescription2EXT_win32_to_host(&in[i], &out[i]);
7962     }
7963
7964     return out;
7965 }
7966 #endif /* USE_STRUCT_CONVERSION */
7967
7968 #if defined(USE_STRUCT_CONVERSION)
7969 static inline void convert_VkVertexInputAttributeDescription2EXT_win32_to_host(const VkVertexInputAttributeDescription2EXT32 *in, VkVertexInputAttributeDescription2EXT *out)
7970 {
7971     if (!in) return;
7972
7973     out->sType = in->sType;
7974     out->pNext = in->pNext;
7975     out->location = in->location;
7976     out->binding = in->binding;
7977     out->format = in->format;
7978     out->offset = in->offset;
7979 }
7980 #endif /* USE_STRUCT_CONVERSION */
7981
7982 #if defined(USE_STRUCT_CONVERSION)
7983 static inline const VkVertexInputAttributeDescription2EXT *convert_VkVertexInputAttributeDescription2EXT_array_win32_to_host(struct conversion_context *ctx, const VkVertexInputAttributeDescription2EXT32 *in, uint32_t count)
7984 {
7985     VkVertexInputAttributeDescription2EXT *out;
7986     unsigned int i;
7987
7988     if (!in || !count) return NULL;
7989
7990     out = conversion_context_alloc(ctx, count * sizeof(*out));
7991     for (i = 0; i < count; i++)
7992     {
7993         convert_VkVertexInputAttributeDescription2EXT_win32_to_host(&in[i], &out[i]);
7994     }
7995
7996     return out;
7997 }
7998 #endif /* USE_STRUCT_CONVERSION */
7999
8000 #if defined(USE_STRUCT_CONVERSION)
8001 static inline void convert_VkStridedDeviceAddressRegionKHR_win32_to_host(const VkStridedDeviceAddressRegionKHR32 *in, VkStridedDeviceAddressRegionKHR *out)
8002 {
8003     if (!in) return;
8004
8005     out->deviceAddress = in->deviceAddress;
8006     out->stride = in->stride;
8007     out->size = in->size;
8008 }
8009 #endif /* USE_STRUCT_CONVERSION */
8010
8011 #if defined(USE_STRUCT_CONVERSION)
8012 static inline const VkDependencyInfo *convert_VkDependencyInfo_array_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, uint32_t count)
8013 {
8014     VkDependencyInfo *out;
8015     unsigned int i;
8016
8017     if (!in || !count) return NULL;
8018
8019     out = conversion_context_alloc(ctx, count * sizeof(*out));
8020     for (i = 0; i < count; i++)
8021     {
8022         convert_VkDependencyInfo_win32_to_host(ctx, &in[i], &out[i]);
8023     }
8024
8025     return out;
8026 }
8027 #endif /* USE_STRUCT_CONVERSION */
8028
8029 #if defined(USE_STRUCT_CONVERSION)
8030 static inline void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoKHR32 *in, VkAccelerationStructureCreateInfoKHR *out)
8031 {
8032     const VkBaseInStructure *in_header;
8033     VkBaseOutStructure *out_header = (void *)out;
8034
8035     if (!in) return;
8036
8037     out->sType = in->sType;
8038     out->pNext = NULL;
8039     out->createFlags = in->createFlags;
8040     out->buffer = in->buffer;
8041     out->offset = in->offset;
8042     out->size = in->size;
8043     out->type = in->type;
8044     out->deviceAddress = in->deviceAddress;
8045
8046     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8047     {
8048         switch (in_header->sType)
8049         {
8050         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
8051         {
8052             VkAccelerationStructureMotionInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8053             const VkAccelerationStructureMotionInfoNV32 *in_ext = (const VkAccelerationStructureMotionInfoNV32 *)in_header;
8054             out_ext->sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV;
8055             out_ext->pNext = NULL;
8056             out_ext->maxInstances = in_ext->maxInstances;
8057             out_ext->flags = in_ext->flags;
8058             out_header->pNext = (void *)out_ext;
8059             out_header = (void *)out_ext;
8060             break;
8061         }
8062         default:
8063             FIXME("Unhandled sType %u.", in_header->sType);
8064             break;
8065         }
8066     }
8067 }
8068 #endif /* USE_STRUCT_CONVERSION */
8069
8070 #if defined(USE_STRUCT_CONVERSION)
8071 static inline void convert_VkAccelerationStructureCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoNV32 *in, VkAccelerationStructureCreateInfoNV *out)
8072 {
8073     if (!in) return;
8074
8075     out->sType = in->sType;
8076     out->pNext = in->pNext;
8077     out->compactedSize = in->compactedSize;
8078     convert_VkAccelerationStructureInfoNV_win32_to_host(ctx, &in->info, &out->info);
8079 }
8080 #endif /* USE_STRUCT_CONVERSION */
8081
8082 #if defined(USE_STRUCT_CONVERSION)
8083 static inline void convert_VkBufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, VkBufferCreateInfo *out)
8084 {
8085     const VkBaseInStructure *in_header;
8086     VkBaseOutStructure *out_header = (void *)out;
8087
8088     if (!in) return;
8089
8090     out->sType = in->sType;
8091     out->pNext = NULL;
8092     out->flags = in->flags;
8093     out->size = in->size;
8094     out->usage = in->usage;
8095     out->sharingMode = in->sharingMode;
8096     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
8097     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
8098
8099     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8100     {
8101         switch (in_header->sType)
8102         {
8103         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
8104         {
8105             VkDedicatedAllocationBufferCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8106             const VkDedicatedAllocationBufferCreateInfoNV32 *in_ext = (const VkDedicatedAllocationBufferCreateInfoNV32 *)in_header;
8107             out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV;
8108             out_ext->pNext = NULL;
8109             out_ext->dedicatedAllocation = in_ext->dedicatedAllocation;
8110             out_header->pNext = (void *)out_ext;
8111             out_header = (void *)out_ext;
8112             break;
8113         }
8114         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
8115         {
8116             VkExternalMemoryBufferCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8117             const VkExternalMemoryBufferCreateInfo32 *in_ext = (const VkExternalMemoryBufferCreateInfo32 *)in_header;
8118             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
8119             out_ext->pNext = NULL;
8120             out_ext->handleTypes = in_ext->handleTypes;
8121             out_header->pNext = (void *)out_ext;
8122             out_header = (void *)out_ext;
8123             break;
8124         }
8125         case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
8126         {
8127             VkBufferOpaqueCaptureAddressCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8128             const VkBufferOpaqueCaptureAddressCreateInfo32 *in_ext = (const VkBufferOpaqueCaptureAddressCreateInfo32 *)in_header;
8129             out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
8130             out_ext->pNext = NULL;
8131             out_ext->opaqueCaptureAddress = in_ext->opaqueCaptureAddress;
8132             out_header->pNext = (void *)out_ext;
8133             out_header = (void *)out_ext;
8134             break;
8135         }
8136         case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
8137         {
8138             VkBufferDeviceAddressCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8139             const VkBufferDeviceAddressCreateInfoEXT32 *in_ext = (const VkBufferDeviceAddressCreateInfoEXT32 *)in_header;
8140             out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT;
8141             out_ext->pNext = NULL;
8142             out_ext->deviceAddress = in_ext->deviceAddress;
8143             out_header->pNext = (void *)out_ext;
8144             out_header = (void *)out_ext;
8145             break;
8146         }
8147         default:
8148             FIXME("Unhandled sType %u.", in_header->sType);
8149             break;
8150         }
8151     }
8152 }
8153 #endif /* USE_STRUCT_CONVERSION */
8154
8155 #if defined(USE_STRUCT_CONVERSION)
8156 static inline void convert_VkBufferViewCreateInfo_win32_to_host(const VkBufferViewCreateInfo32 *in, VkBufferViewCreateInfo *out)
8157 {
8158     if (!in) return;
8159
8160     out->sType = in->sType;
8161     out->pNext = in->pNext;
8162     out->flags = in->flags;
8163     out->buffer = in->buffer;
8164     out->format = in->format;
8165     out->offset = in->offset;
8166     out->range = in->range;
8167 }
8168 #endif /* USE_STRUCT_CONVERSION */
8169
8170 #if defined(USE_STRUCT_CONVERSION)
8171 static inline void convert_VkCommandPoolCreateInfo_win32_to_host(const VkCommandPoolCreateInfo32 *in, VkCommandPoolCreateInfo *out)
8172 {
8173     if (!in) return;
8174
8175     out->sType = in->sType;
8176     out->pNext = in->pNext;
8177     out->flags = in->flags;
8178     out->queueFamilyIndex = in->queueFamilyIndex;
8179 }
8180 #endif /* USE_STRUCT_CONVERSION */
8181
8182 #if defined(USE_STRUCT_CONVERSION)
8183 static inline void convert_VkPipelineCreationFeedback_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out)
8184 {
8185     if (!in) return;
8186
8187     out->flags = in->flags;
8188     out->duration = in->duration;
8189 }
8190 #endif /* USE_STRUCT_CONVERSION */
8191
8192 #if defined(USE_STRUCT_CONVERSION)
8193 static inline VkPipelineCreationFeedback *convert_VkPipelineCreationFeedback_array_win32_to_host(struct conversion_context *ctx, const VkPipelineCreationFeedback32 *in, uint32_t count)
8194 {
8195     VkPipelineCreationFeedback *out;
8196     if (!in || !count) return NULL;
8197
8198     out = conversion_context_alloc(ctx, count * sizeof(*out));
8199
8200     return out;
8201 }
8202 #endif /* USE_STRUCT_CONVERSION */
8203
8204 #if defined(USE_STRUCT_CONVERSION)
8205 static inline void convert_VkPipelineCreationFeedback_array_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out, uint32_t count)
8206 {
8207     unsigned int i;
8208
8209     if (!in) return;
8210
8211     for (i = 0; i < count; i++)
8212     {
8213         convert_VkPipelineCreationFeedback_host_to_win32(&in[i], &out[i]);
8214     }
8215 }
8216 #endif /* USE_STRUCT_CONVERSION */
8217
8218 #if !defined(USE_STRUCT_CONVERSION)
8219 static inline void convert_VkPipelineShaderStageCreateInfo_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, VkPipelineShaderStageCreateInfo *out)
8220 {
8221     const VkBaseInStructure *in_header;
8222     VkBaseOutStructure *out_header = (void *)out;
8223
8224     if (!in) return;
8225
8226     out->sType = in->sType;
8227     out->pNext = NULL;
8228     out->flags = in->flags;
8229     out->stage = in->stage;
8230     out->module = in->module;
8231     out->pName = in->pName;
8232     out->pSpecializationInfo = in->pSpecializationInfo;
8233
8234     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8235     {
8236         switch (in_header->sType)
8237         {
8238         case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
8239         {
8240             VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8241             const VkShaderModuleCreateInfo *in_ext = (const VkShaderModuleCreateInfo *)in_header;
8242             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
8243             out_ext->pNext = NULL;
8244             out_ext->flags = in_ext->flags;
8245             out_ext->codeSize = in_ext->codeSize;
8246             out_ext->pCode = in_ext->pCode;
8247             out_header->pNext = (void *)out_ext;
8248             out_header = (void *)out_ext;
8249             break;
8250         }
8251         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
8252         {
8253             VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8254             const VkShaderModuleValidationCacheCreateInfoEXT *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT *)in_header;
8255             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
8256             out_ext->pNext = NULL;
8257             out_ext->validationCache = in_ext->validationCache;
8258             out_header->pNext = (void *)out_ext;
8259             out_header = (void *)out_ext;
8260             break;
8261         }
8262         case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
8263         {
8264             VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8265             const VkDebugUtilsObjectNameInfoEXT *in_ext = (const VkDebugUtilsObjectNameInfoEXT *)in_header;
8266             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
8267             out_ext->pNext = NULL;
8268             out_ext->objectType = in_ext->objectType;
8269             out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle);
8270             out_ext->pObjectName = in_ext->pObjectName;
8271             out_header->pNext = (void *)out_ext;
8272             out_header = (void *)out_ext;
8273             break;
8274         }
8275         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
8276         {
8277             VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8278             const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *in_ext = (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)in_header;
8279             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
8280             out_ext->pNext = NULL;
8281             out_ext->requiredSubgroupSize = in_ext->requiredSubgroupSize;
8282             out_header->pNext = (void *)out_ext;
8283             out_header = (void *)out_ext;
8284             break;
8285         }
8286         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
8287         {
8288             VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8289             const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *)in_header;
8290             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
8291             out_ext->pNext = NULL;
8292             out_ext->identifierSize = in_ext->identifierSize;
8293             out_ext->pIdentifier = in_ext->pIdentifier;
8294             out_header->pNext = (void *)out_ext;
8295             out_header = (void *)out_ext;
8296             break;
8297         }
8298         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
8299         {
8300             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8301             const VkPipelineRobustnessCreateInfoEXT *in_ext = (const VkPipelineRobustnessCreateInfoEXT *)in_header;
8302             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
8303             out_ext->pNext = NULL;
8304             out_ext->storageBuffers = in_ext->storageBuffers;
8305             out_ext->uniformBuffers = in_ext->uniformBuffers;
8306             out_ext->vertexInputs = in_ext->vertexInputs;
8307             out_ext->images = in_ext->images;
8308             out_header->pNext = (void *)out_ext;
8309             out_header = (void *)out_ext;
8310             break;
8311         }
8312         default:
8313             FIXME("Unhandled sType %u.", in_header->sType);
8314             break;
8315         }
8316     }
8317 }
8318 #endif /* USE_STRUCT_CONVERSION */
8319
8320 #if defined(USE_STRUCT_CONVERSION)
8321 static inline void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, VkPipelineShaderStageCreateInfo *out)
8322 {
8323     const VkBaseInStructure *in_header;
8324     VkBaseOutStructure *out_header = (void *)out;
8325
8326     if (!in) return;
8327
8328     out->sType = in->sType;
8329     out->pNext = NULL;
8330     out->flags = in->flags;
8331     out->stage = in->stage;
8332     out->module = in->module;
8333     out->pName = in->pName;
8334     out->pSpecializationInfo = in->pSpecializationInfo;
8335
8336     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8337     {
8338         switch (in_header->sType)
8339         {
8340         case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
8341         {
8342             VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8343             const VkShaderModuleCreateInfo32 *in_ext = (const VkShaderModuleCreateInfo32 *)in_header;
8344             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
8345             out_ext->pNext = NULL;
8346             out_ext->flags = in_ext->flags;
8347             out_ext->codeSize = in_ext->codeSize;
8348             out_ext->pCode = in_ext->pCode;
8349             out_header->pNext = (void *)out_ext;
8350             out_header = (void *)out_ext;
8351             break;
8352         }
8353         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
8354         {
8355             VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8356             const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header;
8357             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
8358             out_ext->pNext = NULL;
8359             out_ext->validationCache = in_ext->validationCache;
8360             out_header->pNext = (void *)out_ext;
8361             out_header = (void *)out_ext;
8362             break;
8363         }
8364         case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
8365         {
8366             VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8367             const VkDebugUtilsObjectNameInfoEXT32 *in_ext = (const VkDebugUtilsObjectNameInfoEXT32 *)in_header;
8368             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
8369             out_ext->pNext = NULL;
8370             out_ext->objectType = in_ext->objectType;
8371             out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle);
8372             out_ext->pObjectName = in_ext->pObjectName;
8373             out_header->pNext = (void *)out_ext;
8374             out_header = (void *)out_ext;
8375             break;
8376         }
8377         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
8378         {
8379             VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8380             const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *in_ext = (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *)in_header;
8381             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
8382             out_ext->pNext = NULL;
8383             out_ext->requiredSubgroupSize = in_ext->requiredSubgroupSize;
8384             out_header->pNext = (void *)out_ext;
8385             out_header = (void *)out_ext;
8386             break;
8387         }
8388         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
8389         {
8390             VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8391             const VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 *)in_header;
8392             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
8393             out_ext->pNext = NULL;
8394             out_ext->identifierSize = in_ext->identifierSize;
8395             out_ext->pIdentifier = in_ext->pIdentifier;
8396             out_header->pNext = (void *)out_ext;
8397             out_header = (void *)out_ext;
8398             break;
8399         }
8400         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
8401         {
8402             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8403             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
8404             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
8405             out_ext->pNext = NULL;
8406             out_ext->storageBuffers = in_ext->storageBuffers;
8407             out_ext->uniformBuffers = in_ext->uniformBuffers;
8408             out_ext->vertexInputs = in_ext->vertexInputs;
8409             out_ext->images = in_ext->images;
8410             out_header->pNext = (void *)out_ext;
8411             out_header = (void *)out_ext;
8412             break;
8413         }
8414         default:
8415             FIXME("Unhandled sType %u.", in_header->sType);
8416             break;
8417         }
8418     }
8419 }
8420 #endif /* USE_STRUCT_CONVERSION */
8421
8422 #if !defined(USE_STRUCT_CONVERSION)
8423 static inline void convert_VkComputePipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, VkComputePipelineCreateInfo *out)
8424 {
8425     if (!in) return;
8426
8427     out->sType = in->sType;
8428     out->pNext = in->pNext;
8429     out->flags = in->flags;
8430     convert_VkPipelineShaderStageCreateInfo_win64_to_host(ctx, &in->stage, &out->stage);
8431     out->layout = in->layout;
8432     out->basePipelineHandle = in->basePipelineHandle;
8433     out->basePipelineIndex = in->basePipelineIndex;
8434 }
8435 #endif /* USE_STRUCT_CONVERSION */
8436
8437 #if defined(USE_STRUCT_CONVERSION)
8438 static inline void convert_VkComputePipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, VkComputePipelineCreateInfo *out)
8439 {
8440     const VkBaseInStructure *in_header;
8441     VkBaseOutStructure *out_header = (void *)out;
8442
8443     if (!in) return;
8444
8445     out->sType = in->sType;
8446     out->pNext = NULL;
8447     out->flags = in->flags;
8448     convert_VkPipelineShaderStageCreateInfo_win32_to_host(ctx, &in->stage, &out->stage);
8449     out->layout = in->layout;
8450     out->basePipelineHandle = in->basePipelineHandle;
8451     out->basePipelineIndex = in->basePipelineIndex;
8452
8453     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8454     {
8455         switch (in_header->sType)
8456         {
8457         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
8458         {
8459             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8460             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
8461             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
8462             out_ext->pNext = NULL;
8463             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineCreationFeedback, 1);
8464             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
8465             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
8466             out_header->pNext = (void *)out_ext;
8467             out_header = (void *)out_ext;
8468             break;
8469         }
8470         case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
8471         {
8472             VkSubpassShadingPipelineCreateInfoHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8473             const VkSubpassShadingPipelineCreateInfoHUAWEI32 *in_ext = (const VkSubpassShadingPipelineCreateInfoHUAWEI32 *)in_header;
8474             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI;
8475             out_ext->pNext = NULL;
8476             out_ext->renderPass = in_ext->renderPass;
8477             out_ext->subpass = in_ext->subpass;
8478             out_header->pNext = (void *)out_ext;
8479             out_header = (void *)out_ext;
8480             break;
8481         }
8482         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
8483         {
8484             VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8485             const VkPipelineCompilerControlCreateInfoAMD32 *in_ext = (const VkPipelineCompilerControlCreateInfoAMD32 *)in_header;
8486             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
8487             out_ext->pNext = NULL;
8488             out_ext->compilerControlFlags = in_ext->compilerControlFlags;
8489             out_header->pNext = (void *)out_ext;
8490             out_header = (void *)out_ext;
8491             break;
8492         }
8493         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
8494         {
8495             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8496             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
8497             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
8498             out_ext->pNext = NULL;
8499             out_ext->storageBuffers = in_ext->storageBuffers;
8500             out_ext->uniformBuffers = in_ext->uniformBuffers;
8501             out_ext->vertexInputs = in_ext->vertexInputs;
8502             out_ext->images = in_ext->images;
8503             out_header->pNext = (void *)out_ext;
8504             out_header = (void *)out_ext;
8505             break;
8506         }
8507         default:
8508             FIXME("Unhandled sType %u.", in_header->sType);
8509             break;
8510         }
8511     }
8512 }
8513 #endif /* USE_STRUCT_CONVERSION */
8514
8515 #if defined(USE_STRUCT_CONVERSION)
8516 static inline void convert_VkComputePipelineCreateInfo_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out)
8517 {
8518     const VkBaseInStructure *in_header;
8519     VkBaseOutStructure *out_header = (void *)out;
8520
8521     if (!in) return;
8522
8523
8524     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8525     {
8526         switch (in_header->sType)
8527         {
8528         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
8529         {
8530             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
8531             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
8532             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
8533             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, out_ext->pPipelineCreationFeedback, 1);
8534             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, out_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
8535             out_header = (void *)out_ext;
8536             break;
8537         }
8538         default:
8539             break;
8540         }
8541     }
8542 }
8543 #endif /* USE_STRUCT_CONVERSION */
8544
8545 #if !defined(USE_STRUCT_CONVERSION)
8546 static inline const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, uint32_t count)
8547 {
8548     VkComputePipelineCreateInfo *out;
8549     unsigned int i;
8550
8551     if (!in || !count) return NULL;
8552
8553     out = conversion_context_alloc(ctx, count * sizeof(*out));
8554     for (i = 0; i < count; i++)
8555     {
8556         convert_VkComputePipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
8557     }
8558
8559     return out;
8560 }
8561 #endif /* USE_STRUCT_CONVERSION */
8562
8563 #if defined(USE_STRUCT_CONVERSION)
8564 static inline const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, uint32_t count)
8565 {
8566     VkComputePipelineCreateInfo *out;
8567     unsigned int i;
8568
8569     if (!in || !count) return NULL;
8570
8571     out = conversion_context_alloc(ctx, count * sizeof(*out));
8572     for (i = 0; i < count; i++)
8573     {
8574         convert_VkComputePipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
8575     }
8576
8577     return out;
8578 }
8579 #endif /* USE_STRUCT_CONVERSION */
8580
8581 #if defined(USE_STRUCT_CONVERSION)
8582 static inline void convert_VkComputePipelineCreateInfo_array_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out, uint32_t count)
8583 {
8584     unsigned int i;
8585
8586     if (!in) return;
8587
8588     for (i = 0; i < count; i++)
8589     {
8590         convert_VkComputePipelineCreateInfo_host_to_win32(&in[i], &out[i]);
8591     }
8592 }
8593 #endif /* USE_STRUCT_CONVERSION */
8594
8595 #if defined(USE_STRUCT_CONVERSION)
8596 static inline void convert_VkCuFunctionCreateInfoNVX_win32_to_host(const VkCuFunctionCreateInfoNVX32 *in, VkCuFunctionCreateInfoNVX *out)
8597 {
8598     if (!in) return;
8599
8600     out->sType = in->sType;
8601     out->pNext = in->pNext;
8602     out->module = in->module;
8603     out->pName = in->pName;
8604 }
8605 #endif /* USE_STRUCT_CONVERSION */
8606
8607 #if defined(USE_STRUCT_CONVERSION)
8608 static inline void convert_VkCuModuleCreateInfoNVX_win32_to_host(const VkCuModuleCreateInfoNVX32 *in, VkCuModuleCreateInfoNVX *out)
8609 {
8610     if (!in) return;
8611
8612     out->sType = in->sType;
8613     out->pNext = in->pNext;
8614     out->dataSize = in->dataSize;
8615     out->pData = in->pData;
8616 }
8617 #endif /* USE_STRUCT_CONVERSION */
8618
8619 #if defined(USE_STRUCT_CONVERSION)
8620 static inline void convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host(const VkDebugReportCallbackCreateInfoEXT32 *in, VkDebugReportCallbackCreateInfoEXT *out)
8621 {
8622     if (!in) return;
8623
8624     out->sType = in->sType;
8625     out->pNext = in->pNext;
8626     out->flags = in->flags;
8627     out->pfnCallback = in->pfnCallback;
8628     out->pUserData = in->pUserData;
8629 }
8630 #endif /* USE_STRUCT_CONVERSION */
8631
8632 #if defined(USE_STRUCT_CONVERSION)
8633 static inline void convert_VkDebugUtilsMessengerCreateInfoEXT_win32_to_host(const VkDebugUtilsMessengerCreateInfoEXT32 *in, VkDebugUtilsMessengerCreateInfoEXT *out)
8634 {
8635     if (!in) return;
8636
8637     out->sType = in->sType;
8638     out->pNext = in->pNext;
8639     out->flags = in->flags;
8640     out->messageSeverity = in->messageSeverity;
8641     out->messageType = in->messageType;
8642     out->pfnUserCallback = in->pfnUserCallback;
8643     out->pUserData = in->pUserData;
8644 }
8645 #endif /* USE_STRUCT_CONVERSION */
8646
8647 #if defined(USE_STRUCT_CONVERSION)
8648 static inline void convert_VkDescriptorPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorPoolCreateInfo32 *in, VkDescriptorPoolCreateInfo *out)
8649 {
8650     const VkBaseInStructure *in_header;
8651     VkBaseOutStructure *out_header = (void *)out;
8652
8653     if (!in) return;
8654
8655     out->sType = in->sType;
8656     out->pNext = NULL;
8657     out->flags = in->flags;
8658     out->maxSets = in->maxSets;
8659     out->poolSizeCount = in->poolSizeCount;
8660     out->pPoolSizes = in->pPoolSizes;
8661
8662     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8663     {
8664         switch (in_header->sType)
8665         {
8666         case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
8667         {
8668             VkDescriptorPoolInlineUniformBlockCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8669             const VkDescriptorPoolInlineUniformBlockCreateInfo32 *in_ext = (const VkDescriptorPoolInlineUniformBlockCreateInfo32 *)in_header;
8670             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO;
8671             out_ext->pNext = NULL;
8672             out_ext->maxInlineUniformBlockBindings = in_ext->maxInlineUniformBlockBindings;
8673             out_header->pNext = (void *)out_ext;
8674             out_header = (void *)out_ext;
8675             break;
8676         }
8677         case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
8678         {
8679             VkMutableDescriptorTypeCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8680             const VkMutableDescriptorTypeCreateInfoEXT32 *in_ext = (const VkMutableDescriptorTypeCreateInfoEXT32 *)in_header;
8681             out_ext->sType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
8682             out_ext->pNext = NULL;
8683             out_ext->mutableDescriptorTypeListCount = in_ext->mutableDescriptorTypeListCount;
8684             out_ext->pMutableDescriptorTypeLists = in_ext->pMutableDescriptorTypeLists;
8685             out_header->pNext = (void *)out_ext;
8686             out_header = (void *)out_ext;
8687             break;
8688         }
8689         default:
8690             FIXME("Unhandled sType %u.", in_header->sType);
8691             break;
8692         }
8693     }
8694 }
8695 #endif /* USE_STRUCT_CONVERSION */
8696
8697 #if defined(USE_STRUCT_CONVERSION)
8698 static inline void convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutCreateInfo32 *in, VkDescriptorSetLayoutCreateInfo *out)
8699 {
8700     const VkBaseInStructure *in_header;
8701     VkBaseOutStructure *out_header = (void *)out;
8702
8703     if (!in) return;
8704
8705     out->sType = in->sType;
8706     out->pNext = NULL;
8707     out->flags = in->flags;
8708     out->bindingCount = in->bindingCount;
8709     out->pBindings = in->pBindings;
8710
8711     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8712     {
8713         switch (in_header->sType)
8714         {
8715         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
8716         {
8717             VkDescriptorSetLayoutBindingFlagsCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8718             const VkDescriptorSetLayoutBindingFlagsCreateInfo32 *in_ext = (const VkDescriptorSetLayoutBindingFlagsCreateInfo32 *)in_header;
8719             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
8720             out_ext->pNext = NULL;
8721             out_ext->bindingCount = in_ext->bindingCount;
8722             out_ext->pBindingFlags = in_ext->pBindingFlags;
8723             out_header->pNext = (void *)out_ext;
8724             out_header = (void *)out_ext;
8725             break;
8726         }
8727         case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
8728         {
8729             VkMutableDescriptorTypeCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8730             const VkMutableDescriptorTypeCreateInfoEXT32 *in_ext = (const VkMutableDescriptorTypeCreateInfoEXT32 *)in_header;
8731             out_ext->sType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
8732             out_ext->pNext = NULL;
8733             out_ext->mutableDescriptorTypeListCount = in_ext->mutableDescriptorTypeListCount;
8734             out_ext->pMutableDescriptorTypeLists = in_ext->pMutableDescriptorTypeLists;
8735             out_header->pNext = (void *)out_ext;
8736             out_header = (void *)out_ext;
8737             break;
8738         }
8739         default:
8740             FIXME("Unhandled sType %u.", in_header->sType);
8741             break;
8742         }
8743     }
8744 }
8745 #endif /* USE_STRUCT_CONVERSION */
8746
8747 #if defined(USE_STRUCT_CONVERSION)
8748 static inline void convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(const VkDescriptorUpdateTemplateCreateInfo32 *in, VkDescriptorUpdateTemplateCreateInfo *out)
8749 {
8750     if (!in) return;
8751
8752     out->sType = in->sType;
8753     out->pNext = in->pNext;
8754     out->flags = in->flags;
8755     out->descriptorUpdateEntryCount = in->descriptorUpdateEntryCount;
8756     out->pDescriptorUpdateEntries = in->pDescriptorUpdateEntries;
8757     out->templateType = in->templateType;
8758     out->descriptorSetLayout = in->descriptorSetLayout;
8759     out->pipelineBindPoint = in->pipelineBindPoint;
8760     out->pipelineLayout = in->pipelineLayout;
8761     out->set = in->set;
8762 }
8763 #endif /* USE_STRUCT_CONVERSION */
8764
8765 #if !defined(USE_STRUCT_CONVERSION)
8766 static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win64_to_host(struct conversion_context *ctx, const VkPhysicalDevice *in, uint32_t count)
8767 {
8768     VkPhysicalDevice *out;
8769     unsigned int i;
8770
8771     if (!in || !count) return NULL;
8772
8773     out = conversion_context_alloc(ctx, count * sizeof(*out));
8774     for (i = 0; i < count; i++)
8775     {
8776         out[i] = wine_phys_dev_from_handle(in[i])->phys_dev;
8777     }
8778
8779     return out;
8780 }
8781 #endif /* USE_STRUCT_CONVERSION */
8782
8783 #if defined(USE_STRUCT_CONVERSION)
8784 static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDevice *in, uint32_t count)
8785 {
8786     VkPhysicalDevice *out;
8787     unsigned int i;
8788
8789     if (!in || !count) return NULL;
8790
8791     out = conversion_context_alloc(ctx, count * sizeof(*out));
8792     for (i = 0; i < count; i++)
8793     {
8794         out[i] = wine_phys_dev_from_handle(in[i])->phys_dev;
8795     }
8796
8797     return out;
8798 }
8799 #endif /* USE_STRUCT_CONVERSION */
8800
8801 #if defined(USE_STRUCT_CONVERSION)
8802 static inline void convert_VkDeviceQueueCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceQueueCreateInfo32 *in, VkDeviceQueueCreateInfo *out)
8803 {
8804     const VkBaseInStructure *in_header;
8805     VkBaseOutStructure *out_header = (void *)out;
8806
8807     if (!in) return;
8808
8809     out->sType = in->sType;
8810     out->pNext = NULL;
8811     out->flags = in->flags;
8812     out->queueFamilyIndex = in->queueFamilyIndex;
8813     out->queueCount = in->queueCount;
8814     out->pQueuePriorities = in->pQueuePriorities;
8815
8816     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8817     {
8818         switch (in_header->sType)
8819         {
8820         case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR:
8821         {
8822             VkDeviceQueueGlobalPriorityCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8823             const VkDeviceQueueGlobalPriorityCreateInfoKHR32 *in_ext = (const VkDeviceQueueGlobalPriorityCreateInfoKHR32 *)in_header;
8824             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR;
8825             out_ext->pNext = NULL;
8826             out_ext->globalPriority = in_ext->globalPriority;
8827             out_header->pNext = (void *)out_ext;
8828             out_header = (void *)out_ext;
8829             break;
8830         }
8831         default:
8832             FIXME("Unhandled sType %u.", in_header->sType);
8833             break;
8834         }
8835     }
8836 }
8837 #endif /* USE_STRUCT_CONVERSION */
8838
8839 #if defined(USE_STRUCT_CONVERSION)
8840 static inline const VkDeviceQueueCreateInfo *convert_VkDeviceQueueCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkDeviceQueueCreateInfo32 *in, uint32_t count)
8841 {
8842     VkDeviceQueueCreateInfo *out;
8843     unsigned int i;
8844
8845     if (!in || !count) return NULL;
8846
8847     out = conversion_context_alloc(ctx, count * sizeof(*out));
8848     for (i = 0; i < count; i++)
8849     {
8850         convert_VkDeviceQueueCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
8851     }
8852
8853     return out;
8854 }
8855 #endif /* USE_STRUCT_CONVERSION */
8856
8857 #if !defined(USE_STRUCT_CONVERSION)
8858 static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo *in, VkDeviceCreateInfo *out)
8859 {
8860     const VkBaseInStructure *in_header;
8861     VkBaseOutStructure *out_header = (void *)out;
8862
8863     if (!in) return;
8864
8865     out->sType = in->sType;
8866     out->pNext = NULL;
8867     out->flags = in->flags;
8868     out->queueCreateInfoCount = in->queueCreateInfoCount;
8869     out->pQueueCreateInfos = in->pQueueCreateInfos;
8870     out->enabledLayerCount = in->enabledLayerCount;
8871     out->ppEnabledLayerNames = in->ppEnabledLayerNames;
8872     out->enabledExtensionCount = in->enabledExtensionCount;
8873     out->ppEnabledExtensionNames = in->ppEnabledExtensionNames;
8874     out->pEnabledFeatures = in->pEnabledFeatures;
8875
8876     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8877     {
8878         switch (in_header->sType)
8879         {
8880         case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
8881             break;
8882         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
8883         {
8884             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8885             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header;
8886             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
8887             out_ext->pNext = NULL;
8888             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
8889             out_header->pNext = (void *)out_ext;
8890             out_header = (void *)out_ext;
8891             break;
8892         }
8893         case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
8894         {
8895             VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8896             const VkDevicePrivateDataCreateInfo *in_ext = (const VkDevicePrivateDataCreateInfo *)in_header;
8897             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
8898             out_ext->pNext = NULL;
8899             out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount;
8900             out_header->pNext = (void *)out_ext;
8901             out_header = (void *)out_ext;
8902             break;
8903         }
8904         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
8905         {
8906             VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8907             const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header;
8908             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
8909             out_ext->pNext = NULL;
8910             out_ext->privateData = in_ext->privateData;
8911             out_header->pNext = (void *)out_ext;
8912             out_header = (void *)out_ext;
8913             break;
8914         }
8915         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
8916         {
8917             VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8918             const VkPhysicalDeviceFeatures2 *in_ext = (const VkPhysicalDeviceFeatures2 *)in_header;
8919             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
8920             out_ext->pNext = NULL;
8921             out_ext->features = in_ext->features;
8922             out_header->pNext = (void *)out_ext;
8923             out_header = (void *)out_ext;
8924             break;
8925         }
8926         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
8927         {
8928             VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8929             const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header;
8930             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
8931             out_ext->pNext = NULL;
8932             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
8933             out_ext->variablePointers = in_ext->variablePointers;
8934             out_header->pNext = (void *)out_ext;
8935             out_header = (void *)out_ext;
8936             break;
8937         }
8938         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
8939         {
8940             VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8941             const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header;
8942             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
8943             out_ext->pNext = NULL;
8944             out_ext->multiview = in_ext->multiview;
8945             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
8946             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
8947             out_header->pNext = (void *)out_ext;
8948             out_header = (void *)out_ext;
8949             break;
8950         }
8951         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
8952         {
8953             VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8954             const VkDeviceGroupDeviceCreateInfo *in_ext = (const VkDeviceGroupDeviceCreateInfo *)in_header;
8955             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
8956             out_ext->pNext = NULL;
8957             out_ext->physicalDeviceCount = in_ext->physicalDeviceCount;
8958             out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win64_to_host(ctx, in_ext->pPhysicalDevices, in_ext->physicalDeviceCount);
8959             out_header->pNext = (void *)out_ext;
8960             out_header = (void *)out_ext;
8961             break;
8962         }
8963         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
8964         {
8965             VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8966             const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header;
8967             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
8968             out_ext->pNext = NULL;
8969             out_ext->presentId = in_ext->presentId;
8970             out_header->pNext = (void *)out_ext;
8971             out_header = (void *)out_ext;
8972             break;
8973         }
8974         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
8975         {
8976             VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8977             const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header;
8978             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
8979             out_ext->pNext = NULL;
8980             out_ext->presentWait = in_ext->presentWait;
8981             out_header->pNext = (void *)out_ext;
8982             out_header = (void *)out_ext;
8983             break;
8984         }
8985         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
8986         {
8987             VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8988             const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header;
8989             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
8990             out_ext->pNext = NULL;
8991             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
8992             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
8993             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
8994             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
8995             out_header->pNext = (void *)out_ext;
8996             out_header = (void *)out_ext;
8997             break;
8998         }
8999         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
9000         {
9001             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9002             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header;
9003             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
9004             out_ext->pNext = NULL;
9005             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
9006             out_header->pNext = (void *)out_ext;
9007             out_header = (void *)out_ext;
9008             break;
9009         }
9010         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
9011         {
9012             VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9013             const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header;
9014             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
9015             out_ext->pNext = NULL;
9016             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
9017             out_header->pNext = (void *)out_ext;
9018             out_header = (void *)out_ext;
9019             break;
9020         }
9021         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
9022         {
9023             VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9024             const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header;
9025             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
9026             out_ext->pNext = NULL;
9027             out_ext->protectedMemory = in_ext->protectedMemory;
9028             out_header->pNext = (void *)out_ext;
9029             out_header = (void *)out_ext;
9030             break;
9031         }
9032         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
9033         {
9034             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9035             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)in_header;
9036             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
9037             out_ext->pNext = NULL;
9038             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
9039             out_header->pNext = (void *)out_ext;
9040             out_header = (void *)out_ext;
9041             break;
9042         }
9043         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
9044         {
9045             VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9046             const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header;
9047             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
9048             out_ext->pNext = NULL;
9049             out_ext->multiDraw = in_ext->multiDraw;
9050             out_header->pNext = (void *)out_ext;
9051             out_header = (void *)out_ext;
9052             break;
9053         }
9054         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
9055         {
9056             VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9057             const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header;
9058             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
9059             out_ext->pNext = NULL;
9060             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
9061             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
9062             out_header->pNext = (void *)out_ext;
9063             out_header = (void *)out_ext;
9064             break;
9065         }
9066         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
9067         {
9068             VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9069             const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header;
9070             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
9071             out_ext->pNext = NULL;
9072             out_ext->maintenance4 = in_ext->maintenance4;
9073             out_header->pNext = (void *)out_ext;
9074             out_header = (void *)out_ext;
9075             break;
9076         }
9077         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
9078         {
9079             VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9080             const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header;
9081             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
9082             out_ext->pNext = NULL;
9083             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
9084             out_header->pNext = (void *)out_ext;
9085             out_header = (void *)out_ext;
9086             break;
9087         }
9088         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
9089         {
9090             VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9091             const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header;
9092             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
9093             out_ext->pNext = NULL;
9094             out_ext->shaderFloat16 = in_ext->shaderFloat16;
9095             out_ext->shaderInt8 = in_ext->shaderInt8;
9096             out_header->pNext = (void *)out_ext;
9097             out_header = (void *)out_ext;
9098             break;
9099         }
9100         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
9101         {
9102             VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9103             const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header;
9104             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
9105             out_ext->pNext = NULL;
9106             out_ext->hostQueryReset = in_ext->hostQueryReset;
9107             out_header->pNext = (void *)out_ext;
9108             out_header = (void *)out_ext;
9109             break;
9110         }
9111         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
9112         {
9113             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9114             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *)in_header;
9115             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
9116             out_ext->pNext = NULL;
9117             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
9118             out_header->pNext = (void *)out_ext;
9119             out_header = (void *)out_ext;
9120             break;
9121         }
9122         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
9123         {
9124             VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9125             const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header;
9126             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
9127             out_ext->pNext = NULL;
9128             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
9129             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
9130             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
9131             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
9132             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
9133             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
9134             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
9135             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
9136             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
9137             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
9138             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
9139             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
9140             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
9141             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
9142             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
9143             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
9144             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
9145             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
9146             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
9147             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
9148             out_header->pNext = (void *)out_ext;
9149             out_header = (void *)out_ext;
9150             break;
9151         }
9152         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
9153         {
9154             VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9155             const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header;
9156             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
9157             out_ext->pNext = NULL;
9158             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
9159             out_header->pNext = (void *)out_ext;
9160             out_header = (void *)out_ext;
9161             break;
9162         }
9163         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
9164         {
9165             VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9166             const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header;
9167             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
9168             out_ext->pNext = NULL;
9169             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
9170             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
9171             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
9172             out_header->pNext = (void *)out_ext;
9173             out_header = (void *)out_ext;
9174             break;
9175         }
9176         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
9177         {
9178             VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9179             const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header;
9180             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
9181             out_ext->pNext = NULL;
9182             out_ext->conditionalRendering = in_ext->conditionalRendering;
9183             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
9184             out_header->pNext = (void *)out_ext;
9185             out_header = (void *)out_ext;
9186             break;
9187         }
9188         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
9189         {
9190             VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9191             const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header;
9192             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
9193             out_ext->pNext = NULL;
9194             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
9195             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
9196             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
9197             out_header->pNext = (void *)out_ext;
9198             out_header = (void *)out_ext;
9199             break;
9200         }
9201         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
9202         {
9203             VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9204             const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header;
9205             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
9206             out_ext->pNext = NULL;
9207             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
9208             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
9209             out_header->pNext = (void *)out_ext;
9210             out_header = (void *)out_ext;
9211             break;
9212         }
9213         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
9214         {
9215             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9216             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header;
9217             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
9218             out_ext->pNext = NULL;
9219             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
9220             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
9221             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
9222             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
9223             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
9224             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
9225             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
9226             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
9227             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
9228             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
9229             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
9230             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
9231             out_header->pNext = (void *)out_ext;
9232             out_header = (void *)out_ext;
9233             break;
9234         }
9235         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
9236         {
9237             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9238             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header;
9239             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
9240             out_ext->pNext = NULL;
9241             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
9242             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
9243             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
9244             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
9245             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
9246             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
9247             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
9248             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
9249             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
9250             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
9251             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
9252             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
9253             out_header->pNext = (void *)out_ext;
9254             out_header = (void *)out_ext;
9255             break;
9256         }
9257         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
9258         {
9259             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9260             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)in_header;
9261             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
9262             out_ext->pNext = NULL;
9263             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
9264             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
9265             out_header->pNext = (void *)out_ext;
9266             out_header = (void *)out_ext;
9267             break;
9268         }
9269         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
9270         {
9271             VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9272             const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header;
9273             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
9274             out_ext->pNext = NULL;
9275             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
9276             out_header->pNext = (void *)out_ext;
9277             out_header = (void *)out_ext;
9278             break;
9279         }
9280         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
9281         {
9282             VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9283             const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header;
9284             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
9285             out_ext->pNext = NULL;
9286             out_ext->transformFeedback = in_ext->transformFeedback;
9287             out_ext->geometryStreams = in_ext->geometryStreams;
9288             out_header->pNext = (void *)out_ext;
9289             out_header = (void *)out_ext;
9290             break;
9291         }
9292         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
9293         {
9294             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9295             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header;
9296             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
9297             out_ext->pNext = NULL;
9298             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
9299             out_header->pNext = (void *)out_ext;
9300             out_header = (void *)out_ext;
9301             break;
9302         }
9303         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
9304         {
9305             VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9306             const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header;
9307             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
9308             out_ext->pNext = NULL;
9309             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
9310             out_header->pNext = (void *)out_ext;
9311             out_header = (void *)out_ext;
9312             break;
9313         }
9314         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
9315         {
9316             VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9317             const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header;
9318             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
9319             out_ext->pNext = NULL;
9320             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
9321             out_header->pNext = (void *)out_ext;
9322             out_header = (void *)out_ext;
9323             break;
9324         }
9325         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
9326         {
9327             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9328             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *)in_header;
9329             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
9330             out_ext->pNext = NULL;
9331             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
9332             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
9333             out_header->pNext = (void *)out_ext;
9334             out_header = (void *)out_ext;
9335             break;
9336         }
9337         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
9338         {
9339             VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9340             const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header;
9341             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
9342             out_ext->pNext = NULL;
9343             out_ext->imageFootprint = in_ext->imageFootprint;
9344             out_header->pNext = (void *)out_ext;
9345             out_header = (void *)out_ext;
9346             break;
9347         }
9348         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
9349         {
9350             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9351             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header;
9352             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
9353             out_ext->pNext = NULL;
9354             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
9355             out_header->pNext = (void *)out_ext;
9356             out_header = (void *)out_ext;
9357             break;
9358         }
9359         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
9360         {
9361             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9362             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header;
9363             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
9364             out_ext->pNext = NULL;
9365             out_ext->indirectCopy = in_ext->indirectCopy;
9366             out_header->pNext = (void *)out_ext;
9367             out_header = (void *)out_ext;
9368             break;
9369         }
9370         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
9371         {
9372             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9373             const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header;
9374             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
9375             out_ext->pNext = NULL;
9376             out_ext->memoryDecompression = in_ext->memoryDecompression;
9377             out_header->pNext = (void *)out_ext;
9378             out_header = (void *)out_ext;
9379             break;
9380         }
9381         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
9382         {
9383             VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9384             const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header;
9385             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
9386             out_ext->pNext = NULL;
9387             out_ext->shadingRateImage = in_ext->shadingRateImage;
9388             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
9389             out_header->pNext = (void *)out_ext;
9390             out_header = (void *)out_ext;
9391             break;
9392         }
9393         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
9394         {
9395             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9396             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header;
9397             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
9398             out_ext->pNext = NULL;
9399             out_ext->invocationMask = in_ext->invocationMask;
9400             out_header->pNext = (void *)out_ext;
9401             out_header = (void *)out_ext;
9402             break;
9403         }
9404         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
9405         {
9406             VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9407             const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header;
9408             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
9409             out_ext->pNext = NULL;
9410             out_ext->taskShader = in_ext->taskShader;
9411             out_ext->meshShader = in_ext->meshShader;
9412             out_header->pNext = (void *)out_ext;
9413             out_header = (void *)out_ext;
9414             break;
9415         }
9416         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
9417         {
9418             VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9419             const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header;
9420             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
9421             out_ext->pNext = NULL;
9422             out_ext->taskShader = in_ext->taskShader;
9423             out_ext->meshShader = in_ext->meshShader;
9424             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
9425             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
9426             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
9427             out_header->pNext = (void *)out_ext;
9428             out_header = (void *)out_ext;
9429             break;
9430         }
9431         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
9432         {
9433             VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9434             const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header;
9435             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
9436             out_ext->pNext = NULL;
9437             out_ext->accelerationStructure = in_ext->accelerationStructure;
9438             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
9439             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
9440             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
9441             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
9442             out_header->pNext = (void *)out_ext;
9443             out_header = (void *)out_ext;
9444             break;
9445         }
9446         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
9447         {
9448             VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9449             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header;
9450             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
9451             out_ext->pNext = NULL;
9452             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
9453             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
9454             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
9455             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
9456             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
9457             out_header->pNext = (void *)out_ext;
9458             out_header = (void *)out_ext;
9459             break;
9460         }
9461         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
9462         {
9463             VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9464             const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header;
9465             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
9466             out_ext->pNext = NULL;
9467             out_ext->rayQuery = in_ext->rayQuery;
9468             out_header->pNext = (void *)out_ext;
9469             out_header = (void *)out_ext;
9470             break;
9471         }
9472         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
9473         {
9474             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9475             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header;
9476             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
9477             out_ext->pNext = NULL;
9478             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
9479             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
9480             out_header->pNext = (void *)out_ext;
9481             out_header = (void *)out_ext;
9482             break;
9483         }
9484         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
9485         {
9486             VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9487             const VkDeviceMemoryOverallocationCreateInfoAMD *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD *)in_header;
9488             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD;
9489             out_ext->pNext = NULL;
9490             out_ext->overallocationBehavior = in_ext->overallocationBehavior;
9491             out_header->pNext = (void *)out_ext;
9492             out_header = (void *)out_ext;
9493             break;
9494         }
9495         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
9496         {
9497             VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9498             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)in_header;
9499             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
9500             out_ext->pNext = NULL;
9501             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
9502             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
9503             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
9504             out_header->pNext = (void *)out_ext;
9505             out_header = (void *)out_ext;
9506             break;
9507         }
9508         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
9509         {
9510             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9511             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header;
9512             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
9513             out_ext->pNext = NULL;
9514             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
9515             out_header->pNext = (void *)out_ext;
9516             out_header = (void *)out_ext;
9517             break;
9518         }
9519         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
9520         {
9521             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9522             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *)in_header;
9523             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
9524             out_ext->pNext = NULL;
9525             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
9526             out_header->pNext = (void *)out_ext;
9527             out_header = (void *)out_ext;
9528             break;
9529         }
9530         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
9531         {
9532             VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9533             const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header;
9534             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
9535             out_ext->pNext = NULL;
9536             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
9537             out_header->pNext = (void *)out_ext;
9538             out_header = (void *)out_ext;
9539             break;
9540         }
9541         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
9542         {
9543             VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9544             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header;
9545             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
9546             out_ext->pNext = NULL;
9547             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
9548             out_header->pNext = (void *)out_ext;
9549             out_header = (void *)out_ext;
9550             break;
9551         }
9552         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
9553         {
9554             VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9555             const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header;
9556             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
9557             out_ext->pNext = NULL;
9558             out_ext->depthClipEnable = in_ext->depthClipEnable;
9559             out_header->pNext = (void *)out_ext;
9560             out_header = (void *)out_ext;
9561             break;
9562         }
9563         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
9564         {
9565             VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9566             const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header;
9567             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
9568             out_ext->pNext = NULL;
9569             out_ext->memoryPriority = in_ext->memoryPriority;
9570             out_header->pNext = (void *)out_ext;
9571             out_header = (void *)out_ext;
9572             break;
9573         }
9574         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
9575         {
9576             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9577             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header;
9578             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
9579             out_ext->pNext = NULL;
9580             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
9581             out_header->pNext = (void *)out_ext;
9582             out_header = (void *)out_ext;
9583             break;
9584         }
9585         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
9586         {
9587             VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9588             const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header;
9589             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
9590             out_ext->pNext = NULL;
9591             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
9592             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
9593             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
9594             out_header->pNext = (void *)out_ext;
9595             out_header = (void *)out_ext;
9596             break;
9597         }
9598         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
9599         {
9600             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9601             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header;
9602             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
9603             out_ext->pNext = NULL;
9604             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
9605             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
9606             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
9607             out_header->pNext = (void *)out_ext;
9608             out_header = (void *)out_ext;
9609             break;
9610         }
9611         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
9612         {
9613             VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9614             const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header;
9615             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
9616             out_ext->pNext = NULL;
9617             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
9618             out_header->pNext = (void *)out_ext;
9619             out_header = (void *)out_ext;
9620             break;
9621         }
9622         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
9623         {
9624             VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9625             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header;
9626             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
9627             out_ext->pNext = NULL;
9628             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
9629             out_header->pNext = (void *)out_ext;
9630             out_header = (void *)out_ext;
9631             break;
9632         }
9633         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
9634         {
9635             VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9636             const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header;
9637             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
9638             out_ext->pNext = NULL;
9639             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
9640             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
9641             out_header->pNext = (void *)out_ext;
9642             out_header = (void *)out_ext;
9643             break;
9644         }
9645         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
9646         {
9647             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9648             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header;
9649             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
9650             out_ext->pNext = NULL;
9651             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
9652             out_header->pNext = (void *)out_ext;
9653             out_header = (void *)out_ext;
9654             break;
9655         }
9656         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
9657         {
9658             VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9659             const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header;
9660             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
9661             out_ext->pNext = NULL;
9662             out_ext->presentBarrier = in_ext->presentBarrier;
9663             out_header->pNext = (void *)out_ext;
9664             out_header = (void *)out_ext;
9665             break;
9666         }
9667         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
9668         {
9669             VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9670             const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header;
9671             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
9672             out_ext->pNext = NULL;
9673             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
9674             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
9675             out_header->pNext = (void *)out_ext;
9676             out_header = (void *)out_ext;
9677             break;
9678         }
9679         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
9680         {
9681             VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9682             const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header;
9683             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
9684             out_ext->pNext = NULL;
9685             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
9686             out_header->pNext = (void *)out_ext;
9687             out_header = (void *)out_ext;
9688             break;
9689         }
9690         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
9691         {
9692             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9693             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header;
9694             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
9695             out_ext->pNext = NULL;
9696             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
9697             out_header->pNext = (void *)out_ext;
9698             out_header = (void *)out_ext;
9699             break;
9700         }
9701         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
9702         {
9703             VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9704             const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header;
9705             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
9706             out_ext->pNext = NULL;
9707             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
9708             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
9709             out_header->pNext = (void *)out_ext;
9710             out_header = (void *)out_ext;
9711             break;
9712         }
9713         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
9714         {
9715             VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9716             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)in_header;
9717             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
9718             out_ext->pNext = NULL;
9719             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
9720             out_header->pNext = (void *)out_ext;
9721             out_header = (void *)out_ext;
9722             break;
9723         }
9724         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
9725         {
9726             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9727             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header;
9728             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
9729             out_ext->pNext = NULL;
9730             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
9731             out_header->pNext = (void *)out_ext;
9732             out_header = (void *)out_ext;
9733             break;
9734         }
9735         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
9736         {
9737             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9738             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header;
9739             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
9740             out_ext->pNext = NULL;
9741             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
9742             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
9743             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
9744             out_header->pNext = (void *)out_ext;
9745             out_header = (void *)out_ext;
9746             break;
9747         }
9748         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
9749         {
9750             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9751             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header;
9752             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
9753             out_ext->pNext = NULL;
9754             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
9755             out_header->pNext = (void *)out_ext;
9756             out_header = (void *)out_ext;
9757             break;
9758         }
9759         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
9760         {
9761             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9762             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header;
9763             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
9764             out_ext->pNext = NULL;
9765             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
9766             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
9767             out_header->pNext = (void *)out_ext;
9768             out_header = (void *)out_ext;
9769             break;
9770         }
9771         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
9772         {
9773             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9774             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header;
9775             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
9776             out_ext->pNext = NULL;
9777             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
9778             out_header->pNext = (void *)out_ext;
9779             out_header = (void *)out_ext;
9780             break;
9781         }
9782         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
9783         {
9784             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9785             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header;
9786             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
9787             out_ext->pNext = NULL;
9788             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
9789             out_header->pNext = (void *)out_ext;
9790             out_header = (void *)out_ext;
9791             break;
9792         }
9793         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
9794         {
9795             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9796             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header;
9797             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
9798             out_ext->pNext = NULL;
9799             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
9800             out_header->pNext = (void *)out_ext;
9801             out_header = (void *)out_ext;
9802             break;
9803         }
9804         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
9805         {
9806             VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9807             const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header;
9808             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
9809             out_ext->pNext = NULL;
9810             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
9811             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
9812             out_header->pNext = (void *)out_ext;
9813             out_header = (void *)out_ext;
9814             break;
9815         }
9816         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
9817         {
9818             VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9819             const VkPhysicalDeviceLineRasterizationFeaturesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)in_header;
9820             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
9821             out_ext->pNext = NULL;
9822             out_ext->rectangularLines = in_ext->rectangularLines;
9823             out_ext->bresenhamLines = in_ext->bresenhamLines;
9824             out_ext->smoothLines = in_ext->smoothLines;
9825             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
9826             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
9827             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
9828             out_header->pNext = (void *)out_ext;
9829             out_header = (void *)out_ext;
9830             break;
9831         }
9832         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
9833         {
9834             VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9835             const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header;
9836             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
9837             out_ext->pNext = NULL;
9838             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
9839             out_header->pNext = (void *)out_ext;
9840             out_header = (void *)out_ext;
9841             break;
9842         }
9843         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
9844         {
9845             VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9846             const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header;
9847             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
9848             out_ext->pNext = NULL;
9849             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
9850             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
9851             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
9852             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
9853             out_ext->multiview = in_ext->multiview;
9854             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
9855             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
9856             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
9857             out_ext->variablePointers = in_ext->variablePointers;
9858             out_ext->protectedMemory = in_ext->protectedMemory;
9859             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
9860             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
9861             out_header->pNext = (void *)out_ext;
9862             out_header = (void *)out_ext;
9863             break;
9864         }
9865         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
9866         {
9867             VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9868             const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header;
9869             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
9870             out_ext->pNext = NULL;
9871             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
9872             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
9873             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
9874             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
9875             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
9876             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
9877             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
9878             out_ext->shaderFloat16 = in_ext->shaderFloat16;
9879             out_ext->shaderInt8 = in_ext->shaderInt8;
9880             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
9881             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
9882             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
9883             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
9884             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
9885             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
9886             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
9887             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
9888             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
9889             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
9890             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
9891             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
9892             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
9893             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
9894             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
9895             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
9896             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
9897             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
9898             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
9899             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
9900             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
9901             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
9902             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
9903             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
9904             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
9905             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
9906             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
9907             out_ext->hostQueryReset = in_ext->hostQueryReset;
9908             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
9909             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
9910             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
9911             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
9912             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
9913             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
9914             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
9915             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
9916             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
9917             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
9918             out_header->pNext = (void *)out_ext;
9919             out_header = (void *)out_ext;
9920             break;
9921         }
9922         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
9923         {
9924             VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9925             const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header;
9926             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
9927             out_ext->pNext = NULL;
9928             out_ext->robustImageAccess = in_ext->robustImageAccess;
9929             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
9930             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
9931             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
9932             out_ext->privateData = in_ext->privateData;
9933             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
9934             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
9935             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
9936             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
9937             out_ext->synchronization2 = in_ext->synchronization2;
9938             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
9939             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
9940             out_ext->dynamicRendering = in_ext->dynamicRendering;
9941             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
9942             out_ext->maintenance4 = in_ext->maintenance4;
9943             out_header->pNext = (void *)out_ext;
9944             out_header = (void *)out_ext;
9945             break;
9946         }
9947         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
9948         {
9949             VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9950             const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header;
9951             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
9952             out_ext->pNext = NULL;
9953             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
9954             out_header->pNext = (void *)out_ext;
9955             out_header = (void *)out_ext;
9956             break;
9957         }
9958         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
9959         {
9960             VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9961             const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header;
9962             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
9963             out_ext->pNext = NULL;
9964             out_ext->customBorderColors = in_ext->customBorderColors;
9965             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
9966             out_header->pNext = (void *)out_ext;
9967             out_header = (void *)out_ext;
9968             break;
9969         }
9970         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
9971         {
9972             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9973             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header;
9974             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
9975             out_ext->pNext = NULL;
9976             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
9977             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
9978             out_header->pNext = (void *)out_ext;
9979             out_header = (void *)out_ext;
9980             break;
9981         }
9982         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
9983         {
9984             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9985             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header;
9986             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
9987             out_ext->pNext = NULL;
9988             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
9989             out_header->pNext = (void *)out_ext;
9990             out_header = (void *)out_ext;
9991             break;
9992         }
9993         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
9994         {
9995             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9996             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header;
9997             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
9998             out_ext->pNext = NULL;
9999             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
10000             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
10001             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
10002             out_header->pNext = (void *)out_ext;
10003             out_header = (void *)out_ext;
10004             break;
10005         }
10006         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
10007         {
10008             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10009             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header;
10010             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
10011             out_ext->pNext = NULL;
10012             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
10013             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
10014             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
10015             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
10016             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
10017             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
10018             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
10019             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
10020             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
10021             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
10022             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
10023             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
10024             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
10025             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
10026             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
10027             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
10028             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
10029             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
10030             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
10031             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
10032             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
10033             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
10034             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
10035             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
10036             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
10037             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
10038             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
10039             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
10040             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
10041             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
10042             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
10043             out_header->pNext = (void *)out_ext;
10044             out_header = (void *)out_ext;
10045             break;
10046         }
10047         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
10048         {
10049             VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10050             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header;
10051             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
10052             out_ext->pNext = NULL;
10053             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
10054             out_header->pNext = (void *)out_ext;
10055             out_header = (void *)out_ext;
10056             break;
10057         }
10058         case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
10059         {
10060             VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10061             const VkDeviceDiagnosticsConfigCreateInfoNV *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV *)in_header;
10062             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
10063             out_ext->pNext = NULL;
10064             out_ext->flags = in_ext->flags;
10065             out_header->pNext = (void *)out_ext;
10066             out_header = (void *)out_ext;
10067             break;
10068         }
10069         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
10070         {
10071             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10072             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header;
10073             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
10074             out_ext->pNext = NULL;
10075             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
10076             out_header->pNext = (void *)out_ext;
10077             out_header = (void *)out_ext;
10078             break;
10079         }
10080         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
10081         {
10082             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10083             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header;
10084             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
10085             out_ext->pNext = NULL;
10086             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
10087             out_header->pNext = (void *)out_ext;
10088             out_header = (void *)out_ext;
10089             break;
10090         }
10091         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
10092         {
10093             VkPhysicalDeviceRobustness2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10094             const VkPhysicalDeviceRobustness2FeaturesEXT *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT *)in_header;
10095             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
10096             out_ext->pNext = NULL;
10097             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
10098             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
10099             out_ext->nullDescriptor = in_ext->nullDescriptor;
10100             out_header->pNext = (void *)out_ext;
10101             out_header = (void *)out_ext;
10102             break;
10103         }
10104         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
10105         {
10106             VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10107             const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header;
10108             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
10109             out_ext->pNext = NULL;
10110             out_ext->robustImageAccess = in_ext->robustImageAccess;
10111             out_header->pNext = (void *)out_ext;
10112             out_header = (void *)out_ext;
10113             break;
10114         }
10115         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
10116         {
10117             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10118             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header;
10119             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
10120             out_ext->pNext = NULL;
10121             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
10122             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
10123             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
10124             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
10125             out_header->pNext = (void *)out_ext;
10126             out_header = (void *)out_ext;
10127             break;
10128         }
10129         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
10130         {
10131             VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10132             const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header;
10133             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
10134             out_ext->pNext = NULL;
10135             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
10136             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
10137             out_header->pNext = (void *)out_ext;
10138             out_header = (void *)out_ext;
10139             break;
10140         }
10141         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
10142         {
10143             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10144             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header;
10145             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
10146             out_ext->pNext = NULL;
10147             out_ext->subpassShading = in_ext->subpassShading;
10148             out_header->pNext = (void *)out_ext;
10149             out_header = (void *)out_ext;
10150             break;
10151         }
10152         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
10153         {
10154             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10155             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header;
10156             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
10157             out_ext->pNext = NULL;
10158             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
10159             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
10160             out_header->pNext = (void *)out_ext;
10161             out_header = (void *)out_ext;
10162             break;
10163         }
10164         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
10165         {
10166             VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10167             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header;
10168             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
10169             out_ext->pNext = NULL;
10170             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
10171             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
10172             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
10173             out_header->pNext = (void *)out_ext;
10174             out_header = (void *)out_ext;
10175             break;
10176         }
10177         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
10178         {
10179             VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10180             const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header;
10181             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
10182             out_ext->pNext = NULL;
10183             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
10184             out_header->pNext = (void *)out_ext;
10185             out_header = (void *)out_ext;
10186             break;
10187         }
10188         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
10189         {
10190             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10191             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header;
10192             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
10193             out_ext->pNext = NULL;
10194             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
10195             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
10196             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
10197             out_header->pNext = (void *)out_ext;
10198             out_header = (void *)out_ext;
10199             break;
10200         }
10201         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
10202         {
10203             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10204             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header;
10205             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
10206             out_ext->pNext = NULL;
10207             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
10208             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
10209             out_header->pNext = (void *)out_ext;
10210             out_header = (void *)out_ext;
10211             break;
10212         }
10213         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
10214         {
10215             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10216             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header;
10217             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
10218             out_ext->pNext = NULL;
10219             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
10220             out_header->pNext = (void *)out_ext;
10221             out_header = (void *)out_ext;
10222             break;
10223         }
10224         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
10225         {
10226             VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10227             const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header;
10228             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
10229             out_ext->pNext = NULL;
10230             out_ext->depthClipControl = in_ext->depthClipControl;
10231             out_header->pNext = (void *)out_ext;
10232             out_header = (void *)out_ext;
10233             break;
10234         }
10235         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
10236         {
10237             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10238             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header;
10239             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
10240             out_ext->pNext = NULL;
10241             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
10242             out_header->pNext = (void *)out_ext;
10243             out_header = (void *)out_ext;
10244             break;
10245         }
10246         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
10247         {
10248             VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10249             const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header;
10250             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
10251             out_ext->pNext = NULL;
10252             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
10253             out_header->pNext = (void *)out_ext;
10254             out_header = (void *)out_ext;
10255             break;
10256         }
10257         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
10258         {
10259             VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10260             const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header;
10261             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
10262             out_ext->pNext = NULL;
10263             out_ext->synchronization2 = in_ext->synchronization2;
10264             out_header->pNext = (void *)out_ext;
10265             out_header = (void *)out_ext;
10266             break;
10267         }
10268         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
10269         {
10270             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10271             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header;
10272             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
10273             out_ext->pNext = NULL;
10274             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
10275             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
10276             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
10277             out_header->pNext = (void *)out_ext;
10278             out_header = (void *)out_ext;
10279             break;
10280         }
10281         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
10282         {
10283             VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10284             const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header;
10285             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
10286             out_ext->pNext = NULL;
10287             out_ext->legacyDithering = in_ext->legacyDithering;
10288             out_header->pNext = (void *)out_ext;
10289             out_header = (void *)out_ext;
10290             break;
10291         }
10292         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
10293         {
10294             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10295             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header;
10296             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
10297             out_ext->pNext = NULL;
10298             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
10299             out_header->pNext = (void *)out_ext;
10300             out_header = (void *)out_ext;
10301             break;
10302         }
10303         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
10304         {
10305             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10306             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *)in_header;
10307             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
10308             out_ext->pNext = NULL;
10309             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
10310             out_header->pNext = (void *)out_ext;
10311             out_header = (void *)out_ext;
10312             break;
10313         }
10314         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
10315         {
10316             VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10317             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header;
10318             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
10319             out_ext->pNext = NULL;
10320             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
10321             out_header->pNext = (void *)out_ext;
10322             out_header = (void *)out_ext;
10323             break;
10324         }
10325         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
10326         {
10327             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10328             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header;
10329             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
10330             out_ext->pNext = NULL;
10331             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
10332             out_header->pNext = (void *)out_ext;
10333             out_header = (void *)out_ext;
10334             break;
10335         }
10336         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
10337         {
10338             VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10339             const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header;
10340             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
10341             out_ext->pNext = NULL;
10342             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
10343             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
10344             out_header->pNext = (void *)out_ext;
10345             out_header = (void *)out_ext;
10346             break;
10347         }
10348         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
10349         {
10350             VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10351             const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header;
10352             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
10353             out_ext->pNext = NULL;
10354             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
10355             out_header->pNext = (void *)out_ext;
10356             out_header = (void *)out_ext;
10357             break;
10358         }
10359         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
10360         {
10361             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10362             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header;
10363             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
10364             out_ext->pNext = NULL;
10365             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
10366             out_header->pNext = (void *)out_ext;
10367             out_header = (void *)out_ext;
10368             break;
10369         }
10370         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
10371         {
10372             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10373             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header;
10374             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
10375             out_ext->pNext = NULL;
10376             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
10377             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
10378             out_header->pNext = (void *)out_ext;
10379             out_header = (void *)out_ext;
10380             break;
10381         }
10382         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
10383         {
10384             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10385             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header;
10386             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
10387             out_ext->pNext = NULL;
10388             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
10389             out_header->pNext = (void *)out_ext;
10390             out_header = (void *)out_ext;
10391             break;
10392         }
10393         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
10394         {
10395             VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10396             const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header;
10397             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
10398             out_ext->pNext = NULL;
10399             out_ext->dynamicRendering = in_ext->dynamicRendering;
10400             out_header->pNext = (void *)out_ext;
10401             out_header = (void *)out_ext;
10402             break;
10403         }
10404         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
10405         {
10406             VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10407             const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header;
10408             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
10409             out_ext->pNext = NULL;
10410             out_ext->minLod = in_ext->minLod;
10411             out_header->pNext = (void *)out_ext;
10412             out_header = (void *)out_ext;
10413             break;
10414         }
10415         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
10416         {
10417             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10418             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header;
10419             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
10420             out_ext->pNext = NULL;
10421             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
10422             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
10423             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
10424             out_header->pNext = (void *)out_ext;
10425             out_header = (void *)out_ext;
10426             break;
10427         }
10428         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
10429         {
10430             VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10431             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header;
10432             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
10433             out_ext->pNext = NULL;
10434             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
10435             out_header->pNext = (void *)out_ext;
10436             out_header = (void *)out_ext;
10437             break;
10438         }
10439         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
10440         {
10441             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10442             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header;
10443             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
10444             out_ext->pNext = NULL;
10445             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
10446             out_header->pNext = (void *)out_ext;
10447             out_header = (void *)out_ext;
10448             break;
10449         }
10450         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
10451         {
10452             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10453             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header;
10454             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
10455             out_ext->pNext = NULL;
10456             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
10457             out_header->pNext = (void *)out_ext;
10458             out_header = (void *)out_ext;
10459             break;
10460         }
10461         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
10462         {
10463             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10464             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header;
10465             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
10466             out_ext->pNext = NULL;
10467             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
10468             out_header->pNext = (void *)out_ext;
10469             out_header = (void *)out_ext;
10470             break;
10471         }
10472         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
10473         {
10474             VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10475             const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header;
10476             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
10477             out_ext->pNext = NULL;
10478             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
10479             out_header->pNext = (void *)out_ext;
10480             out_header = (void *)out_ext;
10481             break;
10482         }
10483         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
10484         {
10485             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10486             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header;
10487             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
10488             out_ext->pNext = NULL;
10489             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
10490             out_header->pNext = (void *)out_ext;
10491             out_header = (void *)out_ext;
10492             break;
10493         }
10494         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
10495         {
10496             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10497             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header;
10498             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
10499             out_ext->pNext = NULL;
10500             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
10501             out_header->pNext = (void *)out_ext;
10502             out_header = (void *)out_ext;
10503             break;
10504         }
10505         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
10506         {
10507             VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10508             const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header;
10509             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
10510             out_ext->pNext = NULL;
10511             out_ext->micromap = in_ext->micromap;
10512             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
10513             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
10514             out_header->pNext = (void *)out_ext;
10515             out_header = (void *)out_ext;
10516             break;
10517         }
10518         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
10519         {
10520             VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10521             const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header;
10522             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
10523             out_ext->pNext = NULL;
10524             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
10525             out_header->pNext = (void *)out_ext;
10526             out_header = (void *)out_ext;
10527             break;
10528         }
10529         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
10530         {
10531             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10532             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *)in_header;
10533             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
10534             out_ext->pNext = NULL;
10535             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
10536             out_header->pNext = (void *)out_ext;
10537             out_header = (void *)out_ext;
10538             break;
10539         }
10540         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
10541         {
10542             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10543             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header;
10544             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
10545             out_ext->pNext = NULL;
10546             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
10547             out_header->pNext = (void *)out_ext;
10548             out_header = (void *)out_ext;
10549             break;
10550         }
10551         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
10552         {
10553             VkPhysicalDevicePipelineRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10554             const VkPhysicalDevicePipelineRobustnessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT *)in_header;
10555             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
10556             out_ext->pNext = NULL;
10557             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
10558             out_header->pNext = (void *)out_ext;
10559             out_header = (void *)out_ext;
10560             break;
10561         }
10562         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
10563         {
10564             VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10565             const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header;
10566             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
10567             out_ext->pNext = NULL;
10568             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
10569             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
10570             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
10571             out_header->pNext = (void *)out_ext;
10572             out_header = (void *)out_ext;
10573             break;
10574         }
10575         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
10576         {
10577             VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10578             const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header;
10579             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
10580             out_ext->pNext = NULL;
10581             out_ext->tileProperties = in_ext->tileProperties;
10582             out_header->pNext = (void *)out_ext;
10583             out_header = (void *)out_ext;
10584             break;
10585         }
10586         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
10587         {
10588             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10589             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header;
10590             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
10591             out_ext->pNext = NULL;
10592             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
10593             out_header->pNext = (void *)out_ext;
10594             out_header = (void *)out_ext;
10595             break;
10596         }
10597         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
10598         {
10599             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10600             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *)in_header;
10601             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
10602             out_ext->pNext = NULL;
10603             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
10604             out_header->pNext = (void *)out_ext;
10605             out_header = (void *)out_ext;
10606             break;
10607         }
10608         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
10609         {
10610             VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10611             const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header;
10612             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
10613             out_ext->pNext = NULL;
10614             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
10615             out_header->pNext = (void *)out_ext;
10616             out_header = (void *)out_ext;
10617             break;
10618         }
10619         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
10620         {
10621             VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10622             const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header;
10623             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
10624             out_ext->pNext = NULL;
10625             out_ext->opticalFlow = in_ext->opticalFlow;
10626             out_header->pNext = (void *)out_ext;
10627             out_header = (void *)out_ext;
10628             break;
10629         }
10630         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
10631         {
10632             VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10633             const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header;
10634             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
10635             out_ext->pNext = NULL;
10636             out_ext->deviceFault = in_ext->deviceFault;
10637             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
10638             out_header->pNext = (void *)out_ext;
10639             out_header = (void *)out_ext;
10640             break;
10641         }
10642         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
10643         {
10644             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10645             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header;
10646             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
10647             out_ext->pNext = NULL;
10648             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
10649             out_header->pNext = (void *)out_ext;
10650             out_header = (void *)out_ext;
10651             break;
10652         }
10653         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
10654         {
10655             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10656             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header;
10657             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
10658             out_ext->pNext = NULL;
10659             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
10660             out_header->pNext = (void *)out_ext;
10661             out_header = (void *)out_ext;
10662             break;
10663         }
10664         default:
10665             FIXME("Unhandled sType %u.", in_header->sType);
10666             break;
10667         }
10668     }
10669 }
10670 #endif /* USE_STRUCT_CONVERSION */
10671
10672 #if defined(USE_STRUCT_CONVERSION)
10673 static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo32 *in, VkDeviceCreateInfo *out)
10674 {
10675     const VkBaseInStructure *in_header;
10676     VkBaseOutStructure *out_header = (void *)out;
10677
10678     if (!in) return;
10679
10680     out->sType = in->sType;
10681     out->pNext = NULL;
10682     out->flags = in->flags;
10683     out->queueCreateInfoCount = in->queueCreateInfoCount;
10684     out->pQueueCreateInfos = convert_VkDeviceQueueCreateInfo_array_win32_to_host(ctx, in->pQueueCreateInfos, in->queueCreateInfoCount);
10685     out->enabledLayerCount = in->enabledLayerCount;
10686     out->ppEnabledLayerNames = in->ppEnabledLayerNames;
10687     out->enabledExtensionCount = in->enabledExtensionCount;
10688     out->ppEnabledExtensionNames = in->ppEnabledExtensionNames;
10689     out->pEnabledFeatures = in->pEnabledFeatures;
10690
10691     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
10692     {
10693         switch (in_header->sType)
10694         {
10695         case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
10696             break;
10697         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
10698         {
10699             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10700             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *)in_header;
10701             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
10702             out_ext->pNext = NULL;
10703             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
10704             out_header->pNext = (void *)out_ext;
10705             out_header = (void *)out_ext;
10706             break;
10707         }
10708         case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
10709         {
10710             VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10711             const VkDevicePrivateDataCreateInfo32 *in_ext = (const VkDevicePrivateDataCreateInfo32 *)in_header;
10712             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
10713             out_ext->pNext = NULL;
10714             out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount;
10715             out_header->pNext = (void *)out_ext;
10716             out_header = (void *)out_ext;
10717             break;
10718         }
10719         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
10720         {
10721             VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10722             const VkPhysicalDevicePrivateDataFeatures32 *in_ext = (const VkPhysicalDevicePrivateDataFeatures32 *)in_header;
10723             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
10724             out_ext->pNext = NULL;
10725             out_ext->privateData = in_ext->privateData;
10726             out_header->pNext = (void *)out_ext;
10727             out_header = (void *)out_ext;
10728             break;
10729         }
10730         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
10731         {
10732             VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10733             const VkPhysicalDeviceFeatures232 *in_ext = (const VkPhysicalDeviceFeatures232 *)in_header;
10734             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
10735             out_ext->pNext = NULL;
10736             out_ext->features = in_ext->features;
10737             out_header->pNext = (void *)out_ext;
10738             out_header = (void *)out_ext;
10739             break;
10740         }
10741         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
10742         {
10743             VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10744             const VkPhysicalDeviceVariablePointersFeatures32 *in_ext = (const VkPhysicalDeviceVariablePointersFeatures32 *)in_header;
10745             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
10746             out_ext->pNext = NULL;
10747             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
10748             out_ext->variablePointers = in_ext->variablePointers;
10749             out_header->pNext = (void *)out_ext;
10750             out_header = (void *)out_ext;
10751             break;
10752         }
10753         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
10754         {
10755             VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10756             const VkPhysicalDeviceMultiviewFeatures32 *in_ext = (const VkPhysicalDeviceMultiviewFeatures32 *)in_header;
10757             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
10758             out_ext->pNext = NULL;
10759             out_ext->multiview = in_ext->multiview;
10760             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
10761             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
10762             out_header->pNext = (void *)out_ext;
10763             out_header = (void *)out_ext;
10764             break;
10765         }
10766         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
10767         {
10768             VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10769             const VkDeviceGroupDeviceCreateInfo32 *in_ext = (const VkDeviceGroupDeviceCreateInfo32 *)in_header;
10770             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
10771             out_ext->pNext = NULL;
10772             out_ext->physicalDeviceCount = in_ext->physicalDeviceCount;
10773             out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win32_to_host(ctx, in_ext->pPhysicalDevices, in_ext->physicalDeviceCount);
10774             out_header->pNext = (void *)out_ext;
10775             out_header = (void *)out_ext;
10776             break;
10777         }
10778         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
10779         {
10780             VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10781             const VkPhysicalDevicePresentIdFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR32 *)in_header;
10782             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
10783             out_ext->pNext = NULL;
10784             out_ext->presentId = in_ext->presentId;
10785             out_header->pNext = (void *)out_ext;
10786             out_header = (void *)out_ext;
10787             break;
10788         }
10789         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
10790         {
10791             VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10792             const VkPhysicalDevicePresentWaitFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR32 *)in_header;
10793             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
10794             out_ext->pNext = NULL;
10795             out_ext->presentWait = in_ext->presentWait;
10796             out_header->pNext = (void *)out_ext;
10797             out_header = (void *)out_ext;
10798             break;
10799         }
10800         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
10801         {
10802             VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10803             const VkPhysicalDevice16BitStorageFeatures32 *in_ext = (const VkPhysicalDevice16BitStorageFeatures32 *)in_header;
10804             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
10805             out_ext->pNext = NULL;
10806             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
10807             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
10808             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
10809             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
10810             out_header->pNext = (void *)out_ext;
10811             out_header = (void *)out_ext;
10812             break;
10813         }
10814         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
10815         {
10816             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10817             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *)in_header;
10818             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
10819             out_ext->pNext = NULL;
10820             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
10821             out_header->pNext = (void *)out_ext;
10822             out_header = (void *)out_ext;
10823             break;
10824         }
10825         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
10826         {
10827             VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10828             const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *)in_header;
10829             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
10830             out_ext->pNext = NULL;
10831             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
10832             out_header->pNext = (void *)out_ext;
10833             out_header = (void *)out_ext;
10834             break;
10835         }
10836         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
10837         {
10838             VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10839             const VkPhysicalDeviceProtectedMemoryFeatures32 *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures32 *)in_header;
10840             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
10841             out_ext->pNext = NULL;
10842             out_ext->protectedMemory = in_ext->protectedMemory;
10843             out_header->pNext = (void *)out_ext;
10844             out_header = (void *)out_ext;
10845             break;
10846         }
10847         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
10848         {
10849             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10850             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *)in_header;
10851             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
10852             out_ext->pNext = NULL;
10853             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
10854             out_header->pNext = (void *)out_ext;
10855             out_header = (void *)out_ext;
10856             break;
10857         }
10858         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
10859         {
10860             VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10861             const VkPhysicalDeviceMultiDrawFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT32 *)in_header;
10862             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
10863             out_ext->pNext = NULL;
10864             out_ext->multiDraw = in_ext->multiDraw;
10865             out_header->pNext = (void *)out_ext;
10866             out_header = (void *)out_ext;
10867             break;
10868         }
10869         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
10870         {
10871             VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10872             const VkPhysicalDeviceInlineUniformBlockFeatures32 *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures32 *)in_header;
10873             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
10874             out_ext->pNext = NULL;
10875             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
10876             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
10877             out_header->pNext = (void *)out_ext;
10878             out_header = (void *)out_ext;
10879             break;
10880         }
10881         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
10882         {
10883             VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10884             const VkPhysicalDeviceMaintenance4Features32 *in_ext = (const VkPhysicalDeviceMaintenance4Features32 *)in_header;
10885             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
10886             out_ext->pNext = NULL;
10887             out_ext->maintenance4 = in_ext->maintenance4;
10888             out_header->pNext = (void *)out_ext;
10889             out_header = (void *)out_ext;
10890             break;
10891         }
10892         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
10893         {
10894             VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10895             const VkPhysicalDeviceShaderDrawParametersFeatures32 *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures32 *)in_header;
10896             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
10897             out_ext->pNext = NULL;
10898             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
10899             out_header->pNext = (void *)out_ext;
10900             out_header = (void *)out_ext;
10901             break;
10902         }
10903         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
10904         {
10905             VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10906             const VkPhysicalDeviceShaderFloat16Int8Features32 *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features32 *)in_header;
10907             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
10908             out_ext->pNext = NULL;
10909             out_ext->shaderFloat16 = in_ext->shaderFloat16;
10910             out_ext->shaderInt8 = in_ext->shaderInt8;
10911             out_header->pNext = (void *)out_ext;
10912             out_header = (void *)out_ext;
10913             break;
10914         }
10915         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
10916         {
10917             VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10918             const VkPhysicalDeviceHostQueryResetFeatures32 *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures32 *)in_header;
10919             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
10920             out_ext->pNext = NULL;
10921             out_ext->hostQueryReset = in_ext->hostQueryReset;
10922             out_header->pNext = (void *)out_ext;
10923             out_header = (void *)out_ext;
10924             break;
10925         }
10926         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
10927         {
10928             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10929             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *)in_header;
10930             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
10931             out_ext->pNext = NULL;
10932             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
10933             out_header->pNext = (void *)out_ext;
10934             out_header = (void *)out_ext;
10935             break;
10936         }
10937         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
10938         {
10939             VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10940             const VkPhysicalDeviceDescriptorIndexingFeatures32 *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures32 *)in_header;
10941             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
10942             out_ext->pNext = NULL;
10943             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
10944             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
10945             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
10946             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
10947             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
10948             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
10949             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
10950             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
10951             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
10952             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
10953             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
10954             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
10955             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
10956             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
10957             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
10958             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
10959             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
10960             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
10961             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
10962             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
10963             out_header->pNext = (void *)out_ext;
10964             out_header = (void *)out_ext;
10965             break;
10966         }
10967         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
10968         {
10969             VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10970             const VkPhysicalDeviceTimelineSemaphoreFeatures32 *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures32 *)in_header;
10971             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
10972             out_ext->pNext = NULL;
10973             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
10974             out_header->pNext = (void *)out_ext;
10975             out_header = (void *)out_ext;
10976             break;
10977         }
10978         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
10979         {
10980             VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10981             const VkPhysicalDevice8BitStorageFeatures32 *in_ext = (const VkPhysicalDevice8BitStorageFeatures32 *)in_header;
10982             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
10983             out_ext->pNext = NULL;
10984             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
10985             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
10986             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
10987             out_header->pNext = (void *)out_ext;
10988             out_header = (void *)out_ext;
10989             break;
10990         }
10991         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
10992         {
10993             VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10994             const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *)in_header;
10995             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
10996             out_ext->pNext = NULL;
10997             out_ext->conditionalRendering = in_ext->conditionalRendering;
10998             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
10999             out_header->pNext = (void *)out_ext;
11000             out_header = (void *)out_ext;
11001             break;
11002         }
11003         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
11004         {
11005             VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11006             const VkPhysicalDeviceVulkanMemoryModelFeatures32 *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures32 *)in_header;
11007             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
11008             out_ext->pNext = NULL;
11009             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
11010             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
11011             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
11012             out_header->pNext = (void *)out_ext;
11013             out_header = (void *)out_ext;
11014             break;
11015         }
11016         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
11017         {
11018             VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11019             const VkPhysicalDeviceShaderAtomicInt64Features32 *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features32 *)in_header;
11020             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
11021             out_ext->pNext = NULL;
11022             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
11023             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
11024             out_header->pNext = (void *)out_ext;
11025             out_header = (void *)out_ext;
11026             break;
11027         }
11028         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
11029         {
11030             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11031             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *)in_header;
11032             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
11033             out_ext->pNext = NULL;
11034             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
11035             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
11036             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
11037             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
11038             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
11039             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
11040             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
11041             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
11042             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
11043             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
11044             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
11045             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
11046             out_header->pNext = (void *)out_ext;
11047             out_header = (void *)out_ext;
11048             break;
11049         }
11050         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
11051         {
11052             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11053             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *)in_header;
11054             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
11055             out_ext->pNext = NULL;
11056             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
11057             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
11058             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
11059             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
11060             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
11061             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
11062             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
11063             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
11064             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
11065             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
11066             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
11067             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
11068             out_header->pNext = (void *)out_ext;
11069             out_header = (void *)out_ext;
11070             break;
11071         }
11072         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
11073         {
11074             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11075             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *)in_header;
11076             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
11077             out_ext->pNext = NULL;
11078             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
11079             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
11080             out_header->pNext = (void *)out_ext;
11081             out_header = (void *)out_ext;
11082             break;
11083         }
11084         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
11085         {
11086             VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11087             const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *)in_header;
11088             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
11089             out_ext->pNext = NULL;
11090             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
11091             out_header->pNext = (void *)out_ext;
11092             out_header = (void *)out_ext;
11093             break;
11094         }
11095         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
11096         {
11097             VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11098             const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *)in_header;
11099             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
11100             out_ext->pNext = NULL;
11101             out_ext->transformFeedback = in_ext->transformFeedback;
11102             out_ext->geometryStreams = in_ext->geometryStreams;
11103             out_header->pNext = (void *)out_ext;
11104             out_header = (void *)out_ext;
11105             break;
11106         }
11107         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
11108         {
11109             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11110             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *)in_header;
11111             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
11112             out_ext->pNext = NULL;
11113             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
11114             out_header->pNext = (void *)out_ext;
11115             out_header = (void *)out_ext;
11116             break;
11117         }
11118         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
11119         {
11120             VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11121             const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *)in_header;
11122             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
11123             out_ext->pNext = NULL;
11124             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
11125             out_header->pNext = (void *)out_ext;
11126             out_header = (void *)out_ext;
11127             break;
11128         }
11129         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
11130         {
11131             VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11132             const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *)in_header;
11133             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
11134             out_ext->pNext = NULL;
11135             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
11136             out_header->pNext = (void *)out_ext;
11137             out_header = (void *)out_ext;
11138             break;
11139         }
11140         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
11141         {
11142             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11143             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *)in_header;
11144             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
11145             out_ext->pNext = NULL;
11146             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
11147             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
11148             out_header->pNext = (void *)out_ext;
11149             out_header = (void *)out_ext;
11150             break;
11151         }
11152         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
11153         {
11154             VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11155             const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *)in_header;
11156             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
11157             out_ext->pNext = NULL;
11158             out_ext->imageFootprint = in_ext->imageFootprint;
11159             out_header->pNext = (void *)out_ext;
11160             out_header = (void *)out_ext;
11161             break;
11162         }
11163         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
11164         {
11165             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11166             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *)in_header;
11167             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
11168             out_ext->pNext = NULL;
11169             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
11170             out_header->pNext = (void *)out_ext;
11171             out_header = (void *)out_ext;
11172             break;
11173         }
11174         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
11175         {
11176             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11177             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *)in_header;
11178             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
11179             out_ext->pNext = NULL;
11180             out_ext->indirectCopy = in_ext->indirectCopy;
11181             out_header->pNext = (void *)out_ext;
11182             out_header = (void *)out_ext;
11183             break;
11184         }
11185         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
11186         {
11187             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11188             const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *)in_header;
11189             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
11190             out_ext->pNext = NULL;
11191             out_ext->memoryDecompression = in_ext->memoryDecompression;
11192             out_header->pNext = (void *)out_ext;
11193             out_header = (void *)out_ext;
11194             break;
11195         }
11196         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
11197         {
11198             VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11199             const VkPhysicalDeviceShadingRateImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV32 *)in_header;
11200             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
11201             out_ext->pNext = NULL;
11202             out_ext->shadingRateImage = in_ext->shadingRateImage;
11203             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
11204             out_header->pNext = (void *)out_ext;
11205             out_header = (void *)out_ext;
11206             break;
11207         }
11208         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
11209         {
11210             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11211             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *)in_header;
11212             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
11213             out_ext->pNext = NULL;
11214             out_ext->invocationMask = in_ext->invocationMask;
11215             out_header->pNext = (void *)out_ext;
11216             out_header = (void *)out_ext;
11217             break;
11218         }
11219         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
11220         {
11221             VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11222             const VkPhysicalDeviceMeshShaderFeaturesNV32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV32 *)in_header;
11223             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
11224             out_ext->pNext = NULL;
11225             out_ext->taskShader = in_ext->taskShader;
11226             out_ext->meshShader = in_ext->meshShader;
11227             out_header->pNext = (void *)out_ext;
11228             out_header = (void *)out_ext;
11229             break;
11230         }
11231         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
11232         {
11233             VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11234             const VkPhysicalDeviceMeshShaderFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT32 *)in_header;
11235             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
11236             out_ext->pNext = NULL;
11237             out_ext->taskShader = in_ext->taskShader;
11238             out_ext->meshShader = in_ext->meshShader;
11239             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
11240             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
11241             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
11242             out_header->pNext = (void *)out_ext;
11243             out_header = (void *)out_ext;
11244             break;
11245         }
11246         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
11247         {
11248             VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11249             const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *)in_header;
11250             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
11251             out_ext->pNext = NULL;
11252             out_ext->accelerationStructure = in_ext->accelerationStructure;
11253             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
11254             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
11255             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
11256             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
11257             out_header->pNext = (void *)out_ext;
11258             out_header = (void *)out_ext;
11259             break;
11260         }
11261         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
11262         {
11263             VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11264             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *)in_header;
11265             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
11266             out_ext->pNext = NULL;
11267             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
11268             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
11269             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
11270             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
11271             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
11272             out_header->pNext = (void *)out_ext;
11273             out_header = (void *)out_ext;
11274             break;
11275         }
11276         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
11277         {
11278             VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11279             const VkPhysicalDeviceRayQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR32 *)in_header;
11280             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
11281             out_ext->pNext = NULL;
11282             out_ext->rayQuery = in_ext->rayQuery;
11283             out_header->pNext = (void *)out_ext;
11284             out_header = (void *)out_ext;
11285             break;
11286         }
11287         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
11288         {
11289             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11290             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *)in_header;
11291             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
11292             out_ext->pNext = NULL;
11293             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
11294             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
11295             out_header->pNext = (void *)out_ext;
11296             out_header = (void *)out_ext;
11297             break;
11298         }
11299         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
11300         {
11301             VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11302             const VkDeviceMemoryOverallocationCreateInfoAMD32 *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD32 *)in_header;
11303             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD;
11304             out_ext->pNext = NULL;
11305             out_ext->overallocationBehavior = in_ext->overallocationBehavior;
11306             out_header->pNext = (void *)out_ext;
11307             out_header = (void *)out_ext;
11308             break;
11309         }
11310         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
11311         {
11312             VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11313             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *)in_header;
11314             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
11315             out_ext->pNext = NULL;
11316             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
11317             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
11318             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
11319             out_header->pNext = (void *)out_ext;
11320             out_header = (void *)out_ext;
11321             break;
11322         }
11323         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
11324         {
11325             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11326             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *)in_header;
11327             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
11328             out_ext->pNext = NULL;
11329             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
11330             out_header->pNext = (void *)out_ext;
11331             out_header = (void *)out_ext;
11332             break;
11333         }
11334         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
11335         {
11336             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11337             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *)in_header;
11338             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
11339             out_ext->pNext = NULL;
11340             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
11341             out_header->pNext = (void *)out_ext;
11342             out_header = (void *)out_ext;
11343             break;
11344         }
11345         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
11346         {
11347             VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11348             const VkPhysicalDeviceScalarBlockLayoutFeatures32 *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures32 *)in_header;
11349             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
11350             out_ext->pNext = NULL;
11351             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
11352             out_header->pNext = (void *)out_ext;
11353             out_header = (void *)out_ext;
11354             break;
11355         }
11356         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
11357         {
11358             VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11359             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *)in_header;
11360             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
11361             out_ext->pNext = NULL;
11362             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
11363             out_header->pNext = (void *)out_ext;
11364             out_header = (void *)out_ext;
11365             break;
11366         }
11367         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
11368         {
11369             VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11370             const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *)in_header;
11371             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
11372             out_ext->pNext = NULL;
11373             out_ext->depthClipEnable = in_ext->depthClipEnable;
11374             out_header->pNext = (void *)out_ext;
11375             out_header = (void *)out_ext;
11376             break;
11377         }
11378         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
11379         {
11380             VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11381             const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *)in_header;
11382             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
11383             out_ext->pNext = NULL;
11384             out_ext->memoryPriority = in_ext->memoryPriority;
11385             out_header->pNext = (void *)out_ext;
11386             out_header = (void *)out_ext;
11387             break;
11388         }
11389         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
11390         {
11391             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11392             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *)in_header;
11393             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
11394             out_ext->pNext = NULL;
11395             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
11396             out_header->pNext = (void *)out_ext;
11397             out_header = (void *)out_ext;
11398             break;
11399         }
11400         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
11401         {
11402             VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11403             const VkPhysicalDeviceBufferDeviceAddressFeatures32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures32 *)in_header;
11404             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
11405             out_ext->pNext = NULL;
11406             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
11407             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
11408             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
11409             out_header->pNext = (void *)out_ext;
11410             out_header = (void *)out_ext;
11411             break;
11412         }
11413         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
11414         {
11415             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11416             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *)in_header;
11417             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
11418             out_ext->pNext = NULL;
11419             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
11420             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
11421             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
11422             out_header->pNext = (void *)out_ext;
11423             out_header = (void *)out_ext;
11424             break;
11425         }
11426         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
11427         {
11428             VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11429             const VkPhysicalDeviceImagelessFramebufferFeatures32 *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures32 *)in_header;
11430             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
11431             out_ext->pNext = NULL;
11432             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
11433             out_header->pNext = (void *)out_ext;
11434             out_header = (void *)out_ext;
11435             break;
11436         }
11437         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
11438         {
11439             VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11440             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *)in_header;
11441             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
11442             out_ext->pNext = NULL;
11443             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
11444             out_header->pNext = (void *)out_ext;
11445             out_header = (void *)out_ext;
11446             break;
11447         }
11448         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
11449         {
11450             VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11451             const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *)in_header;
11452             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
11453             out_ext->pNext = NULL;
11454             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
11455             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
11456             out_header->pNext = (void *)out_ext;
11457             out_header = (void *)out_ext;
11458             break;
11459         }
11460         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
11461         {
11462             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11463             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *)in_header;
11464             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
11465             out_ext->pNext = NULL;
11466             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
11467             out_header->pNext = (void *)out_ext;
11468             out_header = (void *)out_ext;
11469             break;
11470         }
11471         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
11472         {
11473             VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11474             const VkPhysicalDevicePresentBarrierFeaturesNV32 *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV32 *)in_header;
11475             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
11476             out_ext->pNext = NULL;
11477             out_ext->presentBarrier = in_ext->presentBarrier;
11478             out_header->pNext = (void *)out_ext;
11479             out_header = (void *)out_ext;
11480             break;
11481         }
11482         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
11483         {
11484             VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11485             const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *)in_header;
11486             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
11487             out_ext->pNext = NULL;
11488             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
11489             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
11490             out_header->pNext = (void *)out_ext;
11491             out_header = (void *)out_ext;
11492             break;
11493         }
11494         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
11495         {
11496             VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11497             const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *)in_header;
11498             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
11499             out_ext->pNext = NULL;
11500             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
11501             out_header->pNext = (void *)out_ext;
11502             out_header = (void *)out_ext;
11503             break;
11504         }
11505         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
11506         {
11507             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11508             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *)in_header;
11509             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
11510             out_ext->pNext = NULL;
11511             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
11512             out_header->pNext = (void *)out_ext;
11513             out_header = (void *)out_ext;
11514             break;
11515         }
11516         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
11517         {
11518             VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11519             const VkPhysicalDeviceShaderClockFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR32 *)in_header;
11520             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
11521             out_ext->pNext = NULL;
11522             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
11523             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
11524             out_header->pNext = (void *)out_ext;
11525             out_header = (void *)out_ext;
11526             break;
11527         }
11528         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
11529         {
11530             VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11531             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *)in_header;
11532             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
11533             out_ext->pNext = NULL;
11534             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
11535             out_header->pNext = (void *)out_ext;
11536             out_header = (void *)out_ext;
11537             break;
11538         }
11539         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
11540         {
11541             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11542             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *)in_header;
11543             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
11544             out_ext->pNext = NULL;
11545             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
11546             out_header->pNext = (void *)out_ext;
11547             out_header = (void *)out_ext;
11548             break;
11549         }
11550         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
11551         {
11552             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11553             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *)in_header;
11554             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
11555             out_ext->pNext = NULL;
11556             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
11557             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
11558             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
11559             out_header->pNext = (void *)out_ext;
11560             out_header = (void *)out_ext;
11561             break;
11562         }
11563         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
11564         {
11565             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11566             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *)in_header;
11567             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
11568             out_ext->pNext = NULL;
11569             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
11570             out_header->pNext = (void *)out_ext;
11571             out_header = (void *)out_ext;
11572             break;
11573         }
11574         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
11575         {
11576             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11577             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *)in_header;
11578             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
11579             out_ext->pNext = NULL;
11580             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
11581             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
11582             out_header->pNext = (void *)out_ext;
11583             out_header = (void *)out_ext;
11584             break;
11585         }
11586         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
11587         {
11588             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11589             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *)in_header;
11590             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
11591             out_ext->pNext = NULL;
11592             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
11593             out_header->pNext = (void *)out_ext;
11594             out_header = (void *)out_ext;
11595             break;
11596         }
11597         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
11598         {
11599             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11600             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *)in_header;
11601             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
11602             out_ext->pNext = NULL;
11603             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
11604             out_header->pNext = (void *)out_ext;
11605             out_header = (void *)out_ext;
11606             break;
11607         }
11608         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
11609         {
11610             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11611             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *)in_header;
11612             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
11613             out_ext->pNext = NULL;
11614             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
11615             out_header->pNext = (void *)out_ext;
11616             out_header = (void *)out_ext;
11617             break;
11618         }
11619         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
11620         {
11621             VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11622             const VkPhysicalDeviceSubgroupSizeControlFeatures32 *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures32 *)in_header;
11623             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
11624             out_ext->pNext = NULL;
11625             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
11626             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
11627             out_header->pNext = (void *)out_ext;
11628             out_header = (void *)out_ext;
11629             break;
11630         }
11631         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
11632         {
11633             VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11634             const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *)in_header;
11635             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
11636             out_ext->pNext = NULL;
11637             out_ext->rectangularLines = in_ext->rectangularLines;
11638             out_ext->bresenhamLines = in_ext->bresenhamLines;
11639             out_ext->smoothLines = in_ext->smoothLines;
11640             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
11641             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
11642             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
11643             out_header->pNext = (void *)out_ext;
11644             out_header = (void *)out_ext;
11645             break;
11646         }
11647         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
11648         {
11649             VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11650             const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *)in_header;
11651             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
11652             out_ext->pNext = NULL;
11653             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
11654             out_header->pNext = (void *)out_ext;
11655             out_header = (void *)out_ext;
11656             break;
11657         }
11658         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
11659         {
11660             VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11661             const VkPhysicalDeviceVulkan11Features32 *in_ext = (const VkPhysicalDeviceVulkan11Features32 *)in_header;
11662             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
11663             out_ext->pNext = NULL;
11664             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
11665             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
11666             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
11667             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
11668             out_ext->multiview = in_ext->multiview;
11669             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
11670             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
11671             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
11672             out_ext->variablePointers = in_ext->variablePointers;
11673             out_ext->protectedMemory = in_ext->protectedMemory;
11674             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
11675             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
11676             out_header->pNext = (void *)out_ext;
11677             out_header = (void *)out_ext;
11678             break;
11679         }
11680         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
11681         {
11682             VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11683             const VkPhysicalDeviceVulkan12Features32 *in_ext = (const VkPhysicalDeviceVulkan12Features32 *)in_header;
11684             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
11685             out_ext->pNext = NULL;
11686             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
11687             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
11688             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
11689             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
11690             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
11691             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
11692             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
11693             out_ext->shaderFloat16 = in_ext->shaderFloat16;
11694             out_ext->shaderInt8 = in_ext->shaderInt8;
11695             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
11696             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
11697             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
11698             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
11699             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
11700             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
11701             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
11702             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
11703             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
11704             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
11705             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
11706             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
11707             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
11708             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
11709             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
11710             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
11711             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
11712             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
11713             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
11714             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
11715             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
11716             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
11717             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
11718             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
11719             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
11720             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
11721             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
11722             out_ext->hostQueryReset = in_ext->hostQueryReset;
11723             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
11724             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
11725             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
11726             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
11727             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
11728             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
11729             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
11730             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
11731             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
11732             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
11733             out_header->pNext = (void *)out_ext;
11734             out_header = (void *)out_ext;
11735             break;
11736         }
11737         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
11738         {
11739             VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11740             const VkPhysicalDeviceVulkan13Features32 *in_ext = (const VkPhysicalDeviceVulkan13Features32 *)in_header;
11741             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
11742             out_ext->pNext = NULL;
11743             out_ext->robustImageAccess = in_ext->robustImageAccess;
11744             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
11745             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
11746             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
11747             out_ext->privateData = in_ext->privateData;
11748             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
11749             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
11750             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
11751             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
11752             out_ext->synchronization2 = in_ext->synchronization2;
11753             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
11754             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
11755             out_ext->dynamicRendering = in_ext->dynamicRendering;
11756             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
11757             out_ext->maintenance4 = in_ext->maintenance4;
11758             out_header->pNext = (void *)out_ext;
11759             out_header = (void *)out_ext;
11760             break;
11761         }
11762         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
11763         {
11764             VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11765             const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *)in_header;
11766             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
11767             out_ext->pNext = NULL;
11768             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
11769             out_header->pNext = (void *)out_ext;
11770             out_header = (void *)out_ext;
11771             break;
11772         }
11773         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
11774         {
11775             VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11776             const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *)in_header;
11777             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
11778             out_ext->pNext = NULL;
11779             out_ext->customBorderColors = in_ext->customBorderColors;
11780             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
11781             out_header->pNext = (void *)out_ext;
11782             out_header = (void *)out_ext;
11783             break;
11784         }
11785         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
11786         {
11787             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11788             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *)in_header;
11789             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
11790             out_ext->pNext = NULL;
11791             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
11792             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
11793             out_header->pNext = (void *)out_ext;
11794             out_header = (void *)out_ext;
11795             break;
11796         }
11797         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
11798         {
11799             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11800             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *)in_header;
11801             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
11802             out_ext->pNext = NULL;
11803             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
11804             out_header->pNext = (void *)out_ext;
11805             out_header = (void *)out_ext;
11806             break;
11807         }
11808         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
11809         {
11810             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11811             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *)in_header;
11812             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
11813             out_ext->pNext = NULL;
11814             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
11815             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
11816             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
11817             out_header->pNext = (void *)out_ext;
11818             out_header = (void *)out_ext;
11819             break;
11820         }
11821         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
11822         {
11823             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11824             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *)in_header;
11825             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
11826             out_ext->pNext = NULL;
11827             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
11828             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
11829             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
11830             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
11831             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
11832             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
11833             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
11834             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
11835             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
11836             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
11837             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
11838             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
11839             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
11840             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
11841             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
11842             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
11843             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
11844             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
11845             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
11846             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
11847             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
11848             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
11849             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
11850             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
11851             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
11852             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
11853             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
11854             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
11855             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
11856             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
11857             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
11858             out_header->pNext = (void *)out_ext;
11859             out_header = (void *)out_ext;
11860             break;
11861         }
11862         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
11863         {
11864             VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11865             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *)in_header;
11866             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
11867             out_ext->pNext = NULL;
11868             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
11869             out_header->pNext = (void *)out_ext;
11870             out_header = (void *)out_ext;
11871             break;
11872         }
11873         case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
11874         {
11875             VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11876             const VkDeviceDiagnosticsConfigCreateInfoNV32 *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV32 *)in_header;
11877             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
11878             out_ext->pNext = NULL;
11879             out_ext->flags = in_ext->flags;
11880             out_header->pNext = (void *)out_ext;
11881             out_header = (void *)out_ext;
11882             break;
11883         }
11884         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
11885         {
11886             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11887             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *)in_header;
11888             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
11889             out_ext->pNext = NULL;
11890             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
11891             out_header->pNext = (void *)out_ext;
11892             out_header = (void *)out_ext;
11893             break;
11894         }
11895         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
11896         {
11897             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11898             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *)in_header;
11899             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
11900             out_ext->pNext = NULL;
11901             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
11902             out_header->pNext = (void *)out_ext;
11903             out_header = (void *)out_ext;
11904             break;
11905         }
11906         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
11907         {
11908             VkPhysicalDeviceRobustness2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11909             const VkPhysicalDeviceRobustness2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT32 *)in_header;
11910             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
11911             out_ext->pNext = NULL;
11912             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
11913             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
11914             out_ext->nullDescriptor = in_ext->nullDescriptor;
11915             out_header->pNext = (void *)out_ext;
11916             out_header = (void *)out_ext;
11917             break;
11918         }
11919         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
11920         {
11921             VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11922             const VkPhysicalDeviceImageRobustnessFeatures32 *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures32 *)in_header;
11923             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
11924             out_ext->pNext = NULL;
11925             out_ext->robustImageAccess = in_ext->robustImageAccess;
11926             out_header->pNext = (void *)out_ext;
11927             out_header = (void *)out_ext;
11928             break;
11929         }
11930         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
11931         {
11932             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11933             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *)in_header;
11934             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
11935             out_ext->pNext = NULL;
11936             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
11937             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
11938             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
11939             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
11940             out_header->pNext = (void *)out_ext;
11941             out_header = (void *)out_ext;
11942             break;
11943         }
11944         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
11945         {
11946             VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11947             const VkPhysicalDevice4444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT32 *)in_header;
11948             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
11949             out_ext->pNext = NULL;
11950             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
11951             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
11952             out_header->pNext = (void *)out_ext;
11953             out_header = (void *)out_ext;
11954             break;
11955         }
11956         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
11957         {
11958             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11959             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *)in_header;
11960             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
11961             out_ext->pNext = NULL;
11962             out_ext->subpassShading = in_ext->subpassShading;
11963             out_header->pNext = (void *)out_ext;
11964             out_header = (void *)out_ext;
11965             break;
11966         }
11967         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
11968         {
11969             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11970             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *)in_header;
11971             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
11972             out_ext->pNext = NULL;
11973             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
11974             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
11975             out_header->pNext = (void *)out_ext;
11976             out_header = (void *)out_ext;
11977             break;
11978         }
11979         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
11980         {
11981             VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11982             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *)in_header;
11983             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
11984             out_ext->pNext = NULL;
11985             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
11986             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
11987             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
11988             out_header->pNext = (void *)out_ext;
11989             out_header = (void *)out_ext;
11990             break;
11991         }
11992         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
11993         {
11994             VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11995             const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *)in_header;
11996             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
11997             out_ext->pNext = NULL;
11998             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
11999             out_header->pNext = (void *)out_ext;
12000             out_header = (void *)out_ext;
12001             break;
12002         }
12003         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
12004         {
12005             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12006             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *)in_header;
12007             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
12008             out_ext->pNext = NULL;
12009             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
12010             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
12011             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
12012             out_header->pNext = (void *)out_ext;
12013             out_header = (void *)out_ext;
12014             break;
12015         }
12016         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
12017         {
12018             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12019             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *)in_header;
12020             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
12021             out_ext->pNext = NULL;
12022             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
12023             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
12024             out_header->pNext = (void *)out_ext;
12025             out_header = (void *)out_ext;
12026             break;
12027         }
12028         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
12029         {
12030             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12031             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *)in_header;
12032             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
12033             out_ext->pNext = NULL;
12034             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
12035             out_header->pNext = (void *)out_ext;
12036             out_header = (void *)out_ext;
12037             break;
12038         }
12039         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
12040         {
12041             VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12042             const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *)in_header;
12043             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
12044             out_ext->pNext = NULL;
12045             out_ext->depthClipControl = in_ext->depthClipControl;
12046             out_header->pNext = (void *)out_ext;
12047             out_header = (void *)out_ext;
12048             break;
12049         }
12050         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
12051         {
12052             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12053             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *)in_header;
12054             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
12055             out_ext->pNext = NULL;
12056             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
12057             out_header->pNext = (void *)out_ext;
12058             out_header = (void *)out_ext;
12059             break;
12060         }
12061         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
12062         {
12063             VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12064             const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *)in_header;
12065             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
12066             out_ext->pNext = NULL;
12067             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
12068             out_header->pNext = (void *)out_ext;
12069             out_header = (void *)out_ext;
12070             break;
12071         }
12072         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
12073         {
12074             VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12075             const VkPhysicalDeviceSynchronization2Features32 *in_ext = (const VkPhysicalDeviceSynchronization2Features32 *)in_header;
12076             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
12077             out_ext->pNext = NULL;
12078             out_ext->synchronization2 = in_ext->synchronization2;
12079             out_header->pNext = (void *)out_ext;
12080             out_header = (void *)out_ext;
12081             break;
12082         }
12083         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
12084         {
12085             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12086             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *)in_header;
12087             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
12088             out_ext->pNext = NULL;
12089             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
12090             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
12091             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
12092             out_header->pNext = (void *)out_ext;
12093             out_header = (void *)out_ext;
12094             break;
12095         }
12096         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
12097         {
12098             VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12099             const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *)in_header;
12100             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
12101             out_ext->pNext = NULL;
12102             out_ext->legacyDithering = in_ext->legacyDithering;
12103             out_header->pNext = (void *)out_ext;
12104             out_header = (void *)out_ext;
12105             break;
12106         }
12107         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
12108         {
12109             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12110             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *)in_header;
12111             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
12112             out_ext->pNext = NULL;
12113             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
12114             out_header->pNext = (void *)out_ext;
12115             out_header = (void *)out_ext;
12116             break;
12117         }
12118         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
12119         {
12120             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12121             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *)in_header;
12122             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
12123             out_ext->pNext = NULL;
12124             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
12125             out_header->pNext = (void *)out_ext;
12126             out_header = (void *)out_ext;
12127             break;
12128         }
12129         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
12130         {
12131             VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12132             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *)in_header;
12133             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
12134             out_ext->pNext = NULL;
12135             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
12136             out_header->pNext = (void *)out_ext;
12137             out_header = (void *)out_ext;
12138             break;
12139         }
12140         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
12141         {
12142             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12143             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *)in_header;
12144             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
12145             out_ext->pNext = NULL;
12146             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
12147             out_header->pNext = (void *)out_ext;
12148             out_header = (void *)out_ext;
12149             break;
12150         }
12151         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
12152         {
12153             VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12154             const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *)in_header;
12155             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
12156             out_ext->pNext = NULL;
12157             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
12158             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
12159             out_header->pNext = (void *)out_ext;
12160             out_header = (void *)out_ext;
12161             break;
12162         }
12163         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
12164         {
12165             VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12166             const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *)in_header;
12167             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
12168             out_ext->pNext = NULL;
12169             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
12170             out_header->pNext = (void *)out_ext;
12171             out_header = (void *)out_ext;
12172             break;
12173         }
12174         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
12175         {
12176             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12177             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *)in_header;
12178             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
12179             out_ext->pNext = NULL;
12180             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
12181             out_header->pNext = (void *)out_ext;
12182             out_header = (void *)out_ext;
12183             break;
12184         }
12185         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
12186         {
12187             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12188             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *)in_header;
12189             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
12190             out_ext->pNext = NULL;
12191             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
12192             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
12193             out_header->pNext = (void *)out_ext;
12194             out_header = (void *)out_ext;
12195             break;
12196         }
12197         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
12198         {
12199             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12200             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *)in_header;
12201             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
12202             out_ext->pNext = NULL;
12203             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
12204             out_header->pNext = (void *)out_ext;
12205             out_header = (void *)out_ext;
12206             break;
12207         }
12208         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
12209         {
12210             VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12211             const VkPhysicalDeviceDynamicRenderingFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures32 *)in_header;
12212             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
12213             out_ext->pNext = NULL;
12214             out_ext->dynamicRendering = in_ext->dynamicRendering;
12215             out_header->pNext = (void *)out_ext;
12216             out_header = (void *)out_ext;
12217             break;
12218         }
12219         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
12220         {
12221             VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12222             const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *)in_header;
12223             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
12224             out_ext->pNext = NULL;
12225             out_ext->minLod = in_ext->minLod;
12226             out_header->pNext = (void *)out_ext;
12227             out_header = (void *)out_ext;
12228             break;
12229         }
12230         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
12231         {
12232             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12233             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *)in_header;
12234             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
12235             out_ext->pNext = NULL;
12236             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
12237             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
12238             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
12239             out_header->pNext = (void *)out_ext;
12240             out_header = (void *)out_ext;
12241             break;
12242         }
12243         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
12244         {
12245             VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12246             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *)in_header;
12247             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
12248             out_ext->pNext = NULL;
12249             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
12250             out_header->pNext = (void *)out_ext;
12251             out_header = (void *)out_ext;
12252             break;
12253         }
12254         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
12255         {
12256             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12257             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *)in_header;
12258             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
12259             out_ext->pNext = NULL;
12260             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
12261             out_header->pNext = (void *)out_ext;
12262             out_header = (void *)out_ext;
12263             break;
12264         }
12265         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
12266         {
12267             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12268             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *)in_header;
12269             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
12270             out_ext->pNext = NULL;
12271             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
12272             out_header->pNext = (void *)out_ext;
12273             out_header = (void *)out_ext;
12274             break;
12275         }
12276         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
12277         {
12278             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12279             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *)in_header;
12280             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
12281             out_ext->pNext = NULL;
12282             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
12283             out_header->pNext = (void *)out_ext;
12284             out_header = (void *)out_ext;
12285             break;
12286         }
12287         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
12288         {
12289             VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12290             const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *)in_header;
12291             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
12292             out_ext->pNext = NULL;
12293             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
12294             out_header->pNext = (void *)out_ext;
12295             out_header = (void *)out_ext;
12296             break;
12297         }
12298         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
12299         {
12300             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12301             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *)in_header;
12302             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
12303             out_ext->pNext = NULL;
12304             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
12305             out_header->pNext = (void *)out_ext;
12306             out_header = (void *)out_ext;
12307             break;
12308         }
12309         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
12310         {
12311             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12312             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *)in_header;
12313             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
12314             out_ext->pNext = NULL;
12315             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
12316             out_header->pNext = (void *)out_ext;
12317             out_header = (void *)out_ext;
12318             break;
12319         }
12320         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
12321         {
12322             VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12323             const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *)in_header;
12324             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
12325             out_ext->pNext = NULL;
12326             out_ext->micromap = in_ext->micromap;
12327             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
12328             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
12329             out_header->pNext = (void *)out_ext;
12330             out_header = (void *)out_ext;
12331             break;
12332         }
12333         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
12334         {
12335             VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12336             const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *)in_header;
12337             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
12338             out_ext->pNext = NULL;
12339             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
12340             out_header->pNext = (void *)out_ext;
12341             out_header = (void *)out_ext;
12342             break;
12343         }
12344         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
12345         {
12346             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12347             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *)in_header;
12348             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
12349             out_ext->pNext = NULL;
12350             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
12351             out_header->pNext = (void *)out_ext;
12352             out_header = (void *)out_ext;
12353             break;
12354         }
12355         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
12356         {
12357             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12358             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *)in_header;
12359             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
12360             out_ext->pNext = NULL;
12361             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
12362             out_header->pNext = (void *)out_ext;
12363             out_header = (void *)out_ext;
12364             break;
12365         }
12366         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
12367         {
12368             VkPhysicalDevicePipelineRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12369             const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *)in_header;
12370             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
12371             out_ext->pNext = NULL;
12372             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
12373             out_header->pNext = (void *)out_ext;
12374             out_header = (void *)out_ext;
12375             break;
12376         }
12377         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
12378         {
12379             VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12380             const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *)in_header;
12381             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
12382             out_ext->pNext = NULL;
12383             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
12384             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
12385             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
12386             out_header->pNext = (void *)out_ext;
12387             out_header = (void *)out_ext;
12388             break;
12389         }
12390         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
12391         {
12392             VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12393             const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *)in_header;
12394             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
12395             out_ext->pNext = NULL;
12396             out_ext->tileProperties = in_ext->tileProperties;
12397             out_header->pNext = (void *)out_ext;
12398             out_header = (void *)out_ext;
12399             break;
12400         }
12401         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
12402         {
12403             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12404             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *)in_header;
12405             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
12406             out_ext->pNext = NULL;
12407             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
12408             out_header->pNext = (void *)out_ext;
12409             out_header = (void *)out_ext;
12410             break;
12411         }
12412         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
12413         {
12414             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12415             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *)in_header;
12416             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
12417             out_ext->pNext = NULL;
12418             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
12419             out_header->pNext = (void *)out_ext;
12420             out_header = (void *)out_ext;
12421             break;
12422         }
12423         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
12424         {
12425             VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12426             const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *)in_header;
12427             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
12428             out_ext->pNext = NULL;
12429             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
12430             out_header->pNext = (void *)out_ext;
12431             out_header = (void *)out_ext;
12432             break;
12433         }
12434         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
12435         {
12436             VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12437             const VkPhysicalDeviceOpticalFlowFeaturesNV32 *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV32 *)in_header;
12438             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
12439             out_ext->pNext = NULL;
12440             out_ext->opticalFlow = in_ext->opticalFlow;
12441             out_header->pNext = (void *)out_ext;
12442             out_header = (void *)out_ext;
12443             break;
12444         }
12445         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
12446         {
12447             VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12448             const VkPhysicalDeviceFaultFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT32 *)in_header;
12449             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
12450             out_ext->pNext = NULL;
12451             out_ext->deviceFault = in_ext->deviceFault;
12452             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
12453             out_header->pNext = (void *)out_ext;
12454             out_header = (void *)out_ext;
12455             break;
12456         }
12457         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
12458         {
12459             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12460             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *)in_header;
12461             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
12462             out_ext->pNext = NULL;
12463             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
12464             out_header->pNext = (void *)out_ext;
12465             out_header = (void *)out_ext;
12466             break;
12467         }
12468         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
12469         {
12470             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12471             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *)in_header;
12472             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
12473             out_ext->pNext = NULL;
12474             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
12475             out_header->pNext = (void *)out_ext;
12476             out_header = (void *)out_ext;
12477             break;
12478         }
12479         default:
12480             FIXME("Unhandled sType %u.", in_header->sType);
12481             break;
12482         }
12483     }
12484 }
12485 #endif /* USE_STRUCT_CONVERSION */
12486
12487 #if defined(USE_STRUCT_CONVERSION)
12488 static inline void convert_VkEventCreateInfo_win32_to_host(const VkEventCreateInfo32 *in, VkEventCreateInfo *out)
12489 {
12490     if (!in) return;
12491
12492     out->sType = in->sType;
12493     out->pNext = in->pNext;
12494     out->flags = in->flags;
12495 }
12496 #endif /* USE_STRUCT_CONVERSION */
12497
12498 #if defined(USE_STRUCT_CONVERSION)
12499 static inline void convert_VkFenceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkFenceCreateInfo32 *in, VkFenceCreateInfo *out)
12500 {
12501     const VkBaseInStructure *in_header;
12502     VkBaseOutStructure *out_header = (void *)out;
12503
12504     if (!in) return;
12505
12506     out->sType = in->sType;
12507     out->pNext = NULL;
12508     out->flags = in->flags;
12509
12510     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
12511     {
12512         switch (in_header->sType)
12513         {
12514         case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
12515         {
12516             VkExportFenceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12517             const VkExportFenceCreateInfo32 *in_ext = (const VkExportFenceCreateInfo32 *)in_header;
12518             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO;
12519             out_ext->pNext = NULL;
12520             out_ext->handleTypes = in_ext->handleTypes;
12521             out_header->pNext = (void *)out_ext;
12522             out_header = (void *)out_ext;
12523             break;
12524         }
12525         default:
12526             FIXME("Unhandled sType %u.", in_header->sType);
12527             break;
12528         }
12529     }
12530 }
12531 #endif /* USE_STRUCT_CONVERSION */
12532
12533 #if defined(USE_STRUCT_CONVERSION)
12534 static inline void convert_VkFramebufferAttachmentImageInfo_win32_to_host(const VkFramebufferAttachmentImageInfo32 *in, VkFramebufferAttachmentImageInfo *out)
12535 {
12536     if (!in) return;
12537
12538     out->sType = in->sType;
12539     out->pNext = in->pNext;
12540     out->flags = in->flags;
12541     out->usage = in->usage;
12542     out->width = in->width;
12543     out->height = in->height;
12544     out->layerCount = in->layerCount;
12545     out->viewFormatCount = in->viewFormatCount;
12546     out->pViewFormats = in->pViewFormats;
12547 }
12548 #endif /* USE_STRUCT_CONVERSION */
12549
12550 #if defined(USE_STRUCT_CONVERSION)
12551 static inline const VkFramebufferAttachmentImageInfo *convert_VkFramebufferAttachmentImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkFramebufferAttachmentImageInfo32 *in, uint32_t count)
12552 {
12553     VkFramebufferAttachmentImageInfo *out;
12554     unsigned int i;
12555
12556     if (!in || !count) return NULL;
12557
12558     out = conversion_context_alloc(ctx, count * sizeof(*out));
12559     for (i = 0; i < count; i++)
12560     {
12561         convert_VkFramebufferAttachmentImageInfo_win32_to_host(&in[i], &out[i]);
12562     }
12563
12564     return out;
12565 }
12566 #endif /* USE_STRUCT_CONVERSION */
12567
12568 #if defined(USE_STRUCT_CONVERSION)
12569 static inline void convert_VkFramebufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkFramebufferCreateInfo32 *in, VkFramebufferCreateInfo *out)
12570 {
12571     const VkBaseInStructure *in_header;
12572     VkBaseOutStructure *out_header = (void *)out;
12573
12574     if (!in) return;
12575
12576     out->sType = in->sType;
12577     out->pNext = NULL;
12578     out->flags = in->flags;
12579     out->renderPass = in->renderPass;
12580     out->attachmentCount = in->attachmentCount;
12581     out->pAttachments = in->pAttachments;
12582     out->width = in->width;
12583     out->height = in->height;
12584     out->layers = in->layers;
12585
12586     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
12587     {
12588         switch (in_header->sType)
12589         {
12590         case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
12591         {
12592             VkFramebufferAttachmentsCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12593             const VkFramebufferAttachmentsCreateInfo32 *in_ext = (const VkFramebufferAttachmentsCreateInfo32 *)in_header;
12594             out_ext->sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO;
12595             out_ext->pNext = NULL;
12596             out_ext->attachmentImageInfoCount = in_ext->attachmentImageInfoCount;
12597             out_ext->pAttachmentImageInfos = convert_VkFramebufferAttachmentImageInfo_array_win32_to_host(ctx, in_ext->pAttachmentImageInfos, in_ext->attachmentImageInfoCount);
12598             out_header->pNext = (void *)out_ext;
12599             out_header = (void *)out_ext;
12600             break;
12601         }
12602         default:
12603             FIXME("Unhandled sType %u.", in_header->sType);
12604             break;
12605         }
12606     }
12607 }
12608 #endif /* USE_STRUCT_CONVERSION */
12609
12610 #if !defined(USE_STRUCT_CONVERSION)
12611 static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, uint32_t count)
12612 {
12613     VkPipelineShaderStageCreateInfo *out;
12614     unsigned int i;
12615
12616     if (!in || !count) return NULL;
12617
12618     out = conversion_context_alloc(ctx, count * sizeof(*out));
12619     for (i = 0; i < count; i++)
12620     {
12621         convert_VkPipelineShaderStageCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
12622     }
12623
12624     return out;
12625 }
12626 #endif /* USE_STRUCT_CONVERSION */
12627
12628 #if defined(USE_STRUCT_CONVERSION)
12629 static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, uint32_t count)
12630 {
12631     VkPipelineShaderStageCreateInfo *out;
12632     unsigned int i;
12633
12634     if (!in || !count) return NULL;
12635
12636     out = conversion_context_alloc(ctx, count * sizeof(*out));
12637     for (i = 0; i < count; i++)
12638     {
12639         convert_VkPipelineShaderStageCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
12640     }
12641
12642     return out;
12643 }
12644 #endif /* USE_STRUCT_CONVERSION */
12645
12646 #if defined(USE_STRUCT_CONVERSION)
12647 static inline void convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineVertexInputStateCreateInfo32 *in, VkPipelineVertexInputStateCreateInfo *out)
12648 {
12649     const VkBaseInStructure *in_header;
12650     VkBaseOutStructure *out_header = (void *)out;
12651
12652     if (!in) return;
12653
12654     out->sType = in->sType;
12655     out->pNext = NULL;
12656     out->flags = in->flags;
12657     out->vertexBindingDescriptionCount = in->vertexBindingDescriptionCount;
12658     out->pVertexBindingDescriptions = in->pVertexBindingDescriptions;
12659     out->vertexAttributeDescriptionCount = in->vertexAttributeDescriptionCount;
12660     out->pVertexAttributeDescriptions = in->pVertexAttributeDescriptions;
12661
12662     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
12663     {
12664         switch (in_header->sType)
12665         {
12666         case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
12667         {
12668             VkPipelineVertexInputDivisorStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12669             const VkPipelineVertexInputDivisorStateCreateInfoEXT32 *in_ext = (const VkPipelineVertexInputDivisorStateCreateInfoEXT32 *)in_header;
12670             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT;
12671             out_ext->pNext = NULL;
12672             out_ext->vertexBindingDivisorCount = in_ext->vertexBindingDivisorCount;
12673             out_ext->pVertexBindingDivisors = in_ext->pVertexBindingDivisors;
12674             out_header->pNext = (void *)out_ext;
12675             out_header = (void *)out_ext;
12676             break;
12677         }
12678         default:
12679             FIXME("Unhandled sType %u.", in_header->sType);
12680             break;
12681         }
12682     }
12683 }
12684 #endif /* USE_STRUCT_CONVERSION */
12685
12686 #if defined(USE_STRUCT_CONVERSION)
12687 static inline const VkPipelineVertexInputStateCreateInfo *convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineVertexInputStateCreateInfo32 *in, uint32_t count)
12688 {
12689     VkPipelineVertexInputStateCreateInfo *out;
12690     unsigned int i;
12691
12692     if (!in || !count) return NULL;
12693
12694     out = conversion_context_alloc(ctx, count * sizeof(*out));
12695     for (i = 0; i < count; i++)
12696     {
12697         convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
12698     }
12699
12700     return out;
12701 }
12702 #endif /* USE_STRUCT_CONVERSION */
12703
12704 #if defined(USE_STRUCT_CONVERSION)
12705 static inline void convert_VkPipelineTessellationStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineTessellationStateCreateInfo32 *in, VkPipelineTessellationStateCreateInfo *out)
12706 {
12707     const VkBaseInStructure *in_header;
12708     VkBaseOutStructure *out_header = (void *)out;
12709
12710     if (!in) return;
12711
12712     out->sType = in->sType;
12713     out->pNext = NULL;
12714     out->flags = in->flags;
12715     out->patchControlPoints = in->patchControlPoints;
12716
12717     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
12718     {
12719         switch (in_header->sType)
12720         {
12721         case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
12722         {
12723             VkPipelineTessellationDomainOriginStateCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12724             const VkPipelineTessellationDomainOriginStateCreateInfo32 *in_ext = (const VkPipelineTessellationDomainOriginStateCreateInfo32 *)in_header;
12725             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO;
12726             out_ext->pNext = NULL;
12727             out_ext->domainOrigin = in_ext->domainOrigin;
12728             out_header->pNext = (void *)out_ext;
12729             out_header = (void *)out_ext;
12730             break;
12731         }
12732         default:
12733             FIXME("Unhandled sType %u.", in_header->sType);
12734             break;
12735         }
12736     }
12737 }
12738 #endif /* USE_STRUCT_CONVERSION */
12739
12740 #if defined(USE_STRUCT_CONVERSION)
12741 static inline const VkPipelineTessellationStateCreateInfo *convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineTessellationStateCreateInfo32 *in, uint32_t count)
12742 {
12743     VkPipelineTessellationStateCreateInfo *out;
12744     unsigned int i;
12745
12746     if (!in || !count) return NULL;
12747
12748     out = conversion_context_alloc(ctx, count * sizeof(*out));
12749     for (i = 0; i < count; i++)
12750     {
12751         convert_VkPipelineTessellationStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
12752     }
12753
12754     return out;
12755 }
12756 #endif /* USE_STRUCT_CONVERSION */
12757
12758 #if !defined(USE_STRUCT_CONVERSION)
12759 static inline void convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, VkGraphicsShaderGroupCreateInfoNV *out)
12760 {
12761     if (!in) return;
12762
12763     out->sType = in->sType;
12764     out->pNext = in->pNext;
12765     out->stageCount = in->stageCount;
12766     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
12767     out->pVertexInputState = in->pVertexInputState;
12768     out->pTessellationState = in->pTessellationState;
12769 }
12770 #endif /* USE_STRUCT_CONVERSION */
12771
12772 #if defined(USE_STRUCT_CONVERSION)
12773 static inline void convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, VkGraphicsShaderGroupCreateInfoNV *out)
12774 {
12775     if (!in) return;
12776
12777     out->sType = in->sType;
12778     out->pNext = in->pNext;
12779     out->stageCount = in->stageCount;
12780     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, in->pStages, in->stageCount);
12781     out->pVertexInputState = convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(ctx, in->pVertexInputState, 1);
12782     out->pTessellationState = convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(ctx, in->pTessellationState, 1);
12783 }
12784 #endif /* USE_STRUCT_CONVERSION */
12785
12786 #if !defined(USE_STRUCT_CONVERSION)
12787 static inline const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, uint32_t count)
12788 {
12789     VkGraphicsShaderGroupCreateInfoNV *out;
12790     unsigned int i;
12791
12792     if (!in || !count) return NULL;
12793
12794     out = conversion_context_alloc(ctx, count * sizeof(*out));
12795     for (i = 0; i < count; i++)
12796     {
12797         convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]);
12798     }
12799
12800     return out;
12801 }
12802 #endif /* USE_STRUCT_CONVERSION */
12803
12804 #if defined(USE_STRUCT_CONVERSION)
12805 static inline const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, uint32_t count)
12806 {
12807     VkGraphicsShaderGroupCreateInfoNV *out;
12808     unsigned int i;
12809
12810     if (!in || !count) return NULL;
12811
12812     out = conversion_context_alloc(ctx, count * sizeof(*out));
12813     for (i = 0; i < count; i++)
12814     {
12815         convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]);
12816     }
12817
12818     return out;
12819 }
12820 #endif /* USE_STRUCT_CONVERSION */
12821
12822 #if defined(USE_STRUCT_CONVERSION)
12823 static inline void convert_VkPipelineInputAssemblyStateCreateInfo_win32_to_host(const VkPipelineInputAssemblyStateCreateInfo32 *in, VkPipelineInputAssemblyStateCreateInfo *out)
12824 {
12825     if (!in) return;
12826
12827     out->sType = in->sType;
12828     out->pNext = in->pNext;
12829     out->flags = in->flags;
12830     out->topology = in->topology;
12831     out->primitiveRestartEnable = in->primitiveRestartEnable;
12832 }
12833 #endif /* USE_STRUCT_CONVERSION */
12834
12835 #if defined(USE_STRUCT_CONVERSION)
12836 static inline const VkPipelineInputAssemblyStateCreateInfo *convert_VkPipelineInputAssemblyStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineInputAssemblyStateCreateInfo32 *in, uint32_t count)
12837 {
12838     VkPipelineInputAssemblyStateCreateInfo *out;
12839     unsigned int i;
12840
12841     if (!in || !count) return NULL;
12842
12843     out = conversion_context_alloc(ctx, count * sizeof(*out));
12844     for (i = 0; i < count; i++)
12845     {
12846         convert_VkPipelineInputAssemblyStateCreateInfo_win32_to_host(&in[i], &out[i]);
12847     }
12848
12849     return out;
12850 }
12851 #endif /* USE_STRUCT_CONVERSION */
12852
12853 #if defined(USE_STRUCT_CONVERSION)
12854 static inline void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineViewportStateCreateInfo32 *in, VkPipelineViewportStateCreateInfo *out)
12855 {
12856     const VkBaseInStructure *in_header;
12857     VkBaseOutStructure *out_header = (void *)out;
12858
12859     if (!in) return;
12860
12861     out->sType = in->sType;
12862     out->pNext = NULL;
12863     out->flags = in->flags;
12864     out->viewportCount = in->viewportCount;
12865     out->pViewports = in->pViewports;
12866     out->scissorCount = in->scissorCount;
12867     out->pScissors = in->pScissors;
12868
12869     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
12870     {
12871         switch (in_header->sType)
12872         {
12873         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
12874         {
12875             VkPipelineViewportWScalingStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12876             const VkPipelineViewportWScalingStateCreateInfoNV32 *in_ext = (const VkPipelineViewportWScalingStateCreateInfoNV32 *)in_header;
12877             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV;
12878             out_ext->pNext = NULL;
12879             out_ext->viewportWScalingEnable = in_ext->viewportWScalingEnable;
12880             out_ext->viewportCount = in_ext->viewportCount;
12881             out_ext->pViewportWScalings = in_ext->pViewportWScalings;
12882             out_header->pNext = (void *)out_ext;
12883             out_header = (void *)out_ext;
12884             break;
12885         }
12886         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
12887         {
12888             VkPipelineViewportSwizzleStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12889             const VkPipelineViewportSwizzleStateCreateInfoNV32 *in_ext = (const VkPipelineViewportSwizzleStateCreateInfoNV32 *)in_header;
12890             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV;
12891             out_ext->pNext = NULL;
12892             out_ext->flags = in_ext->flags;
12893             out_ext->viewportCount = in_ext->viewportCount;
12894             out_ext->pViewportSwizzles = in_ext->pViewportSwizzles;
12895             out_header->pNext = (void *)out_ext;
12896             out_header = (void *)out_ext;
12897             break;
12898         }
12899         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
12900         {
12901             VkPipelineViewportExclusiveScissorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12902             const VkPipelineViewportExclusiveScissorStateCreateInfoNV32 *in_ext = (const VkPipelineViewportExclusiveScissorStateCreateInfoNV32 *)in_header;
12903             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV;
12904             out_ext->pNext = NULL;
12905             out_ext->exclusiveScissorCount = in_ext->exclusiveScissorCount;
12906             out_ext->pExclusiveScissors = in_ext->pExclusiveScissors;
12907             out_header->pNext = (void *)out_ext;
12908             out_header = (void *)out_ext;
12909             break;
12910         }
12911         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
12912         {
12913             VkPipelineViewportShadingRateImageStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12914             const VkPipelineViewportShadingRateImageStateCreateInfoNV32 *in_ext = (const VkPipelineViewportShadingRateImageStateCreateInfoNV32 *)in_header;
12915             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV;
12916             out_ext->pNext = NULL;
12917             out_ext->shadingRateImageEnable = in_ext->shadingRateImageEnable;
12918             out_ext->viewportCount = in_ext->viewportCount;
12919             out_ext->pShadingRatePalettes = in_ext->pShadingRatePalettes;
12920             out_header->pNext = (void *)out_ext;
12921             out_header = (void *)out_ext;
12922             break;
12923         }
12924         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
12925         {
12926             VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12927             const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *in_ext = (const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *)in_header;
12928             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV;
12929             out_ext->pNext = NULL;
12930             out_ext->sampleOrderType = in_ext->sampleOrderType;
12931             out_ext->customSampleOrderCount = in_ext->customSampleOrderCount;
12932             out_ext->pCustomSampleOrders = in_ext->pCustomSampleOrders;
12933             out_header->pNext = (void *)out_ext;
12934             out_header = (void *)out_ext;
12935             break;
12936         }
12937         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
12938         {
12939             VkPipelineViewportDepthClipControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12940             const VkPipelineViewportDepthClipControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClipControlCreateInfoEXT32 *)in_header;
12941             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT;
12942             out_ext->pNext = NULL;
12943             out_ext->negativeOneToOne = in_ext->negativeOneToOne;
12944             out_header->pNext = (void *)out_ext;
12945             out_header = (void *)out_ext;
12946             break;
12947         }
12948         default:
12949             FIXME("Unhandled sType %u.", in_header->sType);
12950             break;
12951         }
12952     }
12953 }
12954 #endif /* USE_STRUCT_CONVERSION */
12955
12956 #if defined(USE_STRUCT_CONVERSION)
12957 static inline const VkPipelineViewportStateCreateInfo *convert_VkPipelineViewportStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineViewportStateCreateInfo32 *in, uint32_t count)
12958 {
12959     VkPipelineViewportStateCreateInfo *out;
12960     unsigned int i;
12961
12962     if (!in || !count) return NULL;
12963
12964     out = conversion_context_alloc(ctx, count * sizeof(*out));
12965     for (i = 0; i < count; i++)
12966     {
12967         convert_VkPipelineViewportStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
12968     }
12969
12970     return out;
12971 }
12972 #endif /* USE_STRUCT_CONVERSION */
12973
12974 #if defined(USE_STRUCT_CONVERSION)
12975 static inline void convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineRasterizationStateCreateInfo32 *in, VkPipelineRasterizationStateCreateInfo *out)
12976 {
12977     const VkBaseInStructure *in_header;
12978     VkBaseOutStructure *out_header = (void *)out;
12979
12980     if (!in) return;
12981
12982     out->sType = in->sType;
12983     out->pNext = NULL;
12984     out->flags = in->flags;
12985     out->depthClampEnable = in->depthClampEnable;
12986     out->rasterizerDiscardEnable = in->rasterizerDiscardEnable;
12987     out->polygonMode = in->polygonMode;
12988     out->cullMode = in->cullMode;
12989     out->frontFace = in->frontFace;
12990     out->depthBiasEnable = in->depthBiasEnable;
12991     out->depthBiasConstantFactor = in->depthBiasConstantFactor;
12992     out->depthBiasClamp = in->depthBiasClamp;
12993     out->depthBiasSlopeFactor = in->depthBiasSlopeFactor;
12994     out->lineWidth = in->lineWidth;
12995
12996     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
12997     {
12998         switch (in_header->sType)
12999         {
13000         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
13001         {
13002             VkPipelineRasterizationStateRasterizationOrderAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13003             const VkPipelineRasterizationStateRasterizationOrderAMD32 *in_ext = (const VkPipelineRasterizationStateRasterizationOrderAMD32 *)in_header;
13004             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD;
13005             out_ext->pNext = NULL;
13006             out_ext->rasterizationOrder = in_ext->rasterizationOrder;
13007             out_header->pNext = (void *)out_ext;
13008             out_header = (void *)out_ext;
13009             break;
13010         }
13011         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
13012         {
13013             VkPipelineRasterizationConservativeStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13014             const VkPipelineRasterizationConservativeStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationConservativeStateCreateInfoEXT32 *)in_header;
13015             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT;
13016             out_ext->pNext = NULL;
13017             out_ext->flags = in_ext->flags;
13018             out_ext->conservativeRasterizationMode = in_ext->conservativeRasterizationMode;
13019             out_ext->extraPrimitiveOverestimationSize = in_ext->extraPrimitiveOverestimationSize;
13020             out_header->pNext = (void *)out_ext;
13021             out_header = (void *)out_ext;
13022             break;
13023         }
13024         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
13025         {
13026             VkPipelineRasterizationStateStreamCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13027             const VkPipelineRasterizationStateStreamCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationStateStreamCreateInfoEXT32 *)in_header;
13028             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT;
13029             out_ext->pNext = NULL;
13030             out_ext->flags = in_ext->flags;
13031             out_ext->rasterizationStream = in_ext->rasterizationStream;
13032             out_header->pNext = (void *)out_ext;
13033             out_header = (void *)out_ext;
13034             break;
13035         }
13036         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
13037         {
13038             VkPipelineRasterizationDepthClipStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13039             const VkPipelineRasterizationDepthClipStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationDepthClipStateCreateInfoEXT32 *)in_header;
13040             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT;
13041             out_ext->pNext = NULL;
13042             out_ext->flags = in_ext->flags;
13043             out_ext->depthClipEnable = in_ext->depthClipEnable;
13044             out_header->pNext = (void *)out_ext;
13045             out_header = (void *)out_ext;
13046             break;
13047         }
13048         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
13049         {
13050             VkPipelineRasterizationLineStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13051             const VkPipelineRasterizationLineStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationLineStateCreateInfoEXT32 *)in_header;
13052             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT;
13053             out_ext->pNext = NULL;
13054             out_ext->lineRasterizationMode = in_ext->lineRasterizationMode;
13055             out_ext->stippledLineEnable = in_ext->stippledLineEnable;
13056             out_ext->lineStippleFactor = in_ext->lineStippleFactor;
13057             out_ext->lineStipplePattern = in_ext->lineStipplePattern;
13058             out_header->pNext = (void *)out_ext;
13059             out_header = (void *)out_ext;
13060             break;
13061         }
13062         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
13063         {
13064             VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13065             const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 *)in_header;
13066             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT;
13067             out_ext->pNext = NULL;
13068             out_ext->provokingVertexMode = in_ext->provokingVertexMode;
13069             out_header->pNext = (void *)out_ext;
13070             out_header = (void *)out_ext;
13071             break;
13072         }
13073         default:
13074             FIXME("Unhandled sType %u.", in_header->sType);
13075             break;
13076         }
13077     }
13078 }
13079 #endif /* USE_STRUCT_CONVERSION */
13080
13081 #if defined(USE_STRUCT_CONVERSION)
13082 static inline const VkPipelineRasterizationStateCreateInfo *convert_VkPipelineRasterizationStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineRasterizationStateCreateInfo32 *in, uint32_t count)
13083 {
13084     VkPipelineRasterizationStateCreateInfo *out;
13085     unsigned int i;
13086
13087     if (!in || !count) return NULL;
13088
13089     out = conversion_context_alloc(ctx, count * sizeof(*out));
13090     for (i = 0; i < count; i++)
13091     {
13092         convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
13093     }
13094
13095     return out;
13096 }
13097 #endif /* USE_STRUCT_CONVERSION */
13098
13099 #if defined(USE_STRUCT_CONVERSION)
13100 static inline void convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineMultisampleStateCreateInfo32 *in, VkPipelineMultisampleStateCreateInfo *out)
13101 {
13102     const VkBaseInStructure *in_header;
13103     VkBaseOutStructure *out_header = (void *)out;
13104
13105     if (!in) return;
13106
13107     out->sType = in->sType;
13108     out->pNext = NULL;
13109     out->flags = in->flags;
13110     out->rasterizationSamples = in->rasterizationSamples;
13111     out->sampleShadingEnable = in->sampleShadingEnable;
13112     out->minSampleShading = in->minSampleShading;
13113     out->pSampleMask = in->pSampleMask;
13114     out->alphaToCoverageEnable = in->alphaToCoverageEnable;
13115     out->alphaToOneEnable = in->alphaToOneEnable;
13116
13117     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
13118     {
13119         switch (in_header->sType)
13120         {
13121         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
13122         {
13123             VkPipelineCoverageToColorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13124             const VkPipelineCoverageToColorStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageToColorStateCreateInfoNV32 *)in_header;
13125             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV;
13126             out_ext->pNext = NULL;
13127             out_ext->flags = in_ext->flags;
13128             out_ext->coverageToColorEnable = in_ext->coverageToColorEnable;
13129             out_ext->coverageToColorLocation = in_ext->coverageToColorLocation;
13130             out_header->pNext = (void *)out_ext;
13131             out_header = (void *)out_ext;
13132             break;
13133         }
13134         case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
13135         {
13136             VkPipelineSampleLocationsStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13137             const VkPipelineSampleLocationsStateCreateInfoEXT32 *in_ext = (const VkPipelineSampleLocationsStateCreateInfoEXT32 *)in_header;
13138             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT;
13139             out_ext->pNext = NULL;
13140             out_ext->sampleLocationsEnable = in_ext->sampleLocationsEnable;
13141             convert_VkSampleLocationsInfoEXT_win32_to_host(&in_ext->sampleLocationsInfo, &out_ext->sampleLocationsInfo);
13142             out_header->pNext = (void *)out_ext;
13143             out_header = (void *)out_ext;
13144             break;
13145         }
13146         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
13147         {
13148             VkPipelineCoverageModulationStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13149             const VkPipelineCoverageModulationStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageModulationStateCreateInfoNV32 *)in_header;
13150             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV;
13151             out_ext->pNext = NULL;
13152             out_ext->flags = in_ext->flags;
13153             out_ext->coverageModulationMode = in_ext->coverageModulationMode;
13154             out_ext->coverageModulationTableEnable = in_ext->coverageModulationTableEnable;
13155             out_ext->coverageModulationTableCount = in_ext->coverageModulationTableCount;
13156             out_ext->pCoverageModulationTable = in_ext->pCoverageModulationTable;
13157             out_header->pNext = (void *)out_ext;
13158             out_header = (void *)out_ext;
13159             break;
13160         }
13161         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
13162         {
13163             VkPipelineCoverageReductionStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13164             const VkPipelineCoverageReductionStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageReductionStateCreateInfoNV32 *)in_header;
13165             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV;
13166             out_ext->pNext = NULL;
13167             out_ext->flags = in_ext->flags;
13168             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
13169             out_header->pNext = (void *)out_ext;
13170             out_header = (void *)out_ext;
13171             break;
13172         }
13173         default:
13174             FIXME("Unhandled sType %u.", in_header->sType);
13175             break;
13176         }
13177     }
13178 }
13179 #endif /* USE_STRUCT_CONVERSION */
13180
13181 #if defined(USE_STRUCT_CONVERSION)
13182 static inline const VkPipelineMultisampleStateCreateInfo *convert_VkPipelineMultisampleStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineMultisampleStateCreateInfo32 *in, uint32_t count)
13183 {
13184     VkPipelineMultisampleStateCreateInfo *out;
13185     unsigned int i;
13186
13187     if (!in || !count) return NULL;
13188
13189     out = conversion_context_alloc(ctx, count * sizeof(*out));
13190     for (i = 0; i < count; i++)
13191     {
13192         convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
13193     }
13194
13195     return out;
13196 }
13197 #endif /* USE_STRUCT_CONVERSION */
13198
13199 #if defined(USE_STRUCT_CONVERSION)
13200 static inline void convert_VkPipelineDepthStencilStateCreateInfo_win32_to_host(const VkPipelineDepthStencilStateCreateInfo32 *in, VkPipelineDepthStencilStateCreateInfo *out)
13201 {
13202     if (!in) return;
13203
13204     out->sType = in->sType;
13205     out->pNext = in->pNext;
13206     out->flags = in->flags;
13207     out->depthTestEnable = in->depthTestEnable;
13208     out->depthWriteEnable = in->depthWriteEnable;
13209     out->depthCompareOp = in->depthCompareOp;
13210     out->depthBoundsTestEnable = in->depthBoundsTestEnable;
13211     out->stencilTestEnable = in->stencilTestEnable;
13212     out->front = in->front;
13213     out->back = in->back;
13214     out->minDepthBounds = in->minDepthBounds;
13215     out->maxDepthBounds = in->maxDepthBounds;
13216 }
13217 #endif /* USE_STRUCT_CONVERSION */
13218
13219 #if defined(USE_STRUCT_CONVERSION)
13220 static inline const VkPipelineDepthStencilStateCreateInfo *convert_VkPipelineDepthStencilStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineDepthStencilStateCreateInfo32 *in, uint32_t count)
13221 {
13222     VkPipelineDepthStencilStateCreateInfo *out;
13223     unsigned int i;
13224
13225     if (!in || !count) return NULL;
13226
13227     out = conversion_context_alloc(ctx, count * sizeof(*out));
13228     for (i = 0; i < count; i++)
13229     {
13230         convert_VkPipelineDepthStencilStateCreateInfo_win32_to_host(&in[i], &out[i]);
13231     }
13232
13233     return out;
13234 }
13235 #endif /* USE_STRUCT_CONVERSION */
13236
13237 #if defined(USE_STRUCT_CONVERSION)
13238 static inline void convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineColorBlendStateCreateInfo32 *in, VkPipelineColorBlendStateCreateInfo *out)
13239 {
13240     const VkBaseInStructure *in_header;
13241     VkBaseOutStructure *out_header = (void *)out;
13242
13243     if (!in) return;
13244
13245     out->sType = in->sType;
13246     out->pNext = NULL;
13247     out->flags = in->flags;
13248     out->logicOpEnable = in->logicOpEnable;
13249     out->logicOp = in->logicOp;
13250     out->attachmentCount = in->attachmentCount;
13251     out->pAttachments = in->pAttachments;
13252     memcpy(out->blendConstants, in->blendConstants, 4 * sizeof(float));
13253
13254     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
13255     {
13256         switch (in_header->sType)
13257         {
13258         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
13259         {
13260             VkPipelineColorBlendAdvancedStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13261             const VkPipelineColorBlendAdvancedStateCreateInfoEXT32 *in_ext = (const VkPipelineColorBlendAdvancedStateCreateInfoEXT32 *)in_header;
13262             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT;
13263             out_ext->pNext = NULL;
13264             out_ext->srcPremultiplied = in_ext->srcPremultiplied;
13265             out_ext->dstPremultiplied = in_ext->dstPremultiplied;
13266             out_ext->blendOverlap = in_ext->blendOverlap;
13267             out_header->pNext = (void *)out_ext;
13268             out_header = (void *)out_ext;
13269             break;
13270         }
13271         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
13272         {
13273             VkPipelineColorWriteCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13274             const VkPipelineColorWriteCreateInfoEXT32 *in_ext = (const VkPipelineColorWriteCreateInfoEXT32 *)in_header;
13275             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT;
13276             out_ext->pNext = NULL;
13277             out_ext->attachmentCount = in_ext->attachmentCount;
13278             out_ext->pColorWriteEnables = in_ext->pColorWriteEnables;
13279             out_header->pNext = (void *)out_ext;
13280             out_header = (void *)out_ext;
13281             break;
13282         }
13283         default:
13284             FIXME("Unhandled sType %u.", in_header->sType);
13285             break;
13286         }
13287     }
13288 }
13289 #endif /* USE_STRUCT_CONVERSION */
13290
13291 #if defined(USE_STRUCT_CONVERSION)
13292 static inline const VkPipelineColorBlendStateCreateInfo *convert_VkPipelineColorBlendStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineColorBlendStateCreateInfo32 *in, uint32_t count)
13293 {
13294     VkPipelineColorBlendStateCreateInfo *out;
13295     unsigned int i;
13296
13297     if (!in || !count) return NULL;
13298
13299     out = conversion_context_alloc(ctx, count * sizeof(*out));
13300     for (i = 0; i < count; i++)
13301     {
13302         convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
13303     }
13304
13305     return out;
13306 }
13307 #endif /* USE_STRUCT_CONVERSION */
13308
13309 #if defined(USE_STRUCT_CONVERSION)
13310 static inline void convert_VkPipelineDynamicStateCreateInfo_win32_to_host(const VkPipelineDynamicStateCreateInfo32 *in, VkPipelineDynamicStateCreateInfo *out)
13311 {
13312     if (!in) return;
13313
13314     out->sType = in->sType;
13315     out->pNext = in->pNext;
13316     out->flags = in->flags;
13317     out->dynamicStateCount = in->dynamicStateCount;
13318     out->pDynamicStates = in->pDynamicStates;
13319 }
13320 #endif /* USE_STRUCT_CONVERSION */
13321
13322 #if defined(USE_STRUCT_CONVERSION)
13323 static inline const VkPipelineDynamicStateCreateInfo *convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineDynamicStateCreateInfo32 *in, uint32_t count)
13324 {
13325     VkPipelineDynamicStateCreateInfo *out;
13326     unsigned int i;
13327
13328     if (!in || !count) return NULL;
13329
13330     out = conversion_context_alloc(ctx, count * sizeof(*out));
13331     for (i = 0; i < count; i++)
13332     {
13333         convert_VkPipelineDynamicStateCreateInfo_win32_to_host(&in[i], &out[i]);
13334     }
13335
13336     return out;
13337 }
13338 #endif /* USE_STRUCT_CONVERSION */
13339
13340 #if !defined(USE_STRUCT_CONVERSION)
13341 static inline void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, VkGraphicsPipelineCreateInfo *out)
13342 {
13343     const VkBaseInStructure *in_header;
13344     VkBaseOutStructure *out_header = (void *)out;
13345
13346     if (!in) return;
13347
13348     out->sType = in->sType;
13349     out->pNext = NULL;
13350     out->flags = in->flags;
13351     out->stageCount = in->stageCount;
13352     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
13353     out->pVertexInputState = in->pVertexInputState;
13354     out->pInputAssemblyState = in->pInputAssemblyState;
13355     out->pTessellationState = in->pTessellationState;
13356     out->pViewportState = in->pViewportState;
13357     out->pRasterizationState = in->pRasterizationState;
13358     out->pMultisampleState = in->pMultisampleState;
13359     out->pDepthStencilState = in->pDepthStencilState;
13360     out->pColorBlendState = in->pColorBlendState;
13361     out->pDynamicState = in->pDynamicState;
13362     out->layout = in->layout;
13363     out->renderPass = in->renderPass;
13364     out->subpass = in->subpass;
13365     out->basePipelineHandle = in->basePipelineHandle;
13366     out->basePipelineIndex = in->basePipelineIndex;
13367
13368     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
13369     {
13370         switch (in_header->sType)
13371         {
13372         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
13373         {
13374             VkGraphicsPipelineShaderGroupsCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13375             const VkGraphicsPipelineShaderGroupsCreateInfoNV *in_ext = (const VkGraphicsPipelineShaderGroupsCreateInfoNV *)in_header;
13376             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV;
13377             out_ext->pNext = NULL;
13378             out_ext->groupCount = in_ext->groupCount;
13379             out_ext->pGroups = convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(ctx, in_ext->pGroups, in_ext->groupCount);
13380             out_ext->pipelineCount = in_ext->pipelineCount;
13381             out_ext->pPipelines = in_ext->pPipelines;
13382             out_header->pNext = (void *)out_ext;
13383             out_header = (void *)out_ext;
13384             break;
13385         }
13386         case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
13387         {
13388             VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13389             const VkPipelineDiscardRectangleStateCreateInfoEXT *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT *)in_header;
13390             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
13391             out_ext->pNext = NULL;
13392             out_ext->flags = in_ext->flags;
13393             out_ext->discardRectangleMode = in_ext->discardRectangleMode;
13394             out_ext->discardRectangleCount = in_ext->discardRectangleCount;
13395             out_ext->pDiscardRectangles = in_ext->pDiscardRectangles;
13396             out_header->pNext = (void *)out_ext;
13397             out_header = (void *)out_ext;
13398             break;
13399         }
13400         case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
13401         {
13402             VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13403             const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *)in_header;
13404             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
13405             out_ext->pNext = NULL;
13406             out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable;
13407             out_header->pNext = (void *)out_ext;
13408             out_header = (void *)out_ext;
13409             break;
13410         }
13411         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
13412         {
13413             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13414             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
13415             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
13416             out_ext->pNext = NULL;
13417             out_ext->pPipelineCreationFeedback = in_ext->pPipelineCreationFeedback;
13418             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
13419             out_ext->pPipelineStageCreationFeedbacks = in_ext->pPipelineStageCreationFeedbacks;
13420             out_header->pNext = (void *)out_ext;
13421             out_header = (void *)out_ext;
13422             break;
13423         }
13424         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
13425         {
13426             VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13427             const VkPipelineCompilerControlCreateInfoAMD *in_ext = (const VkPipelineCompilerControlCreateInfoAMD *)in_header;
13428             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
13429             out_ext->pNext = NULL;
13430             out_ext->compilerControlFlags = in_ext->compilerControlFlags;
13431             out_header->pNext = (void *)out_ext;
13432             out_header = (void *)out_ext;
13433             break;
13434         }
13435         case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
13436         {
13437             VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13438             const VkPipelineLibraryCreateInfoKHR *in_ext = (const VkPipelineLibraryCreateInfoKHR *)in_header;
13439             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
13440             out_ext->pNext = NULL;
13441             out_ext->libraryCount = in_ext->libraryCount;
13442             out_ext->pLibraries = in_ext->pLibraries;
13443             out_header->pNext = (void *)out_ext;
13444             out_header = (void *)out_ext;
13445             break;
13446         }
13447         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
13448         {
13449             VkPipelineFragmentShadingRateStateCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13450             const VkPipelineFragmentShadingRateStateCreateInfoKHR *in_ext = (const VkPipelineFragmentShadingRateStateCreateInfoKHR *)in_header;
13451             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR;
13452             out_ext->pNext = NULL;
13453             out_ext->fragmentSize = in_ext->fragmentSize;
13454             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
13455             out_header->pNext = (void *)out_ext;
13456             out_header = (void *)out_ext;
13457             break;
13458         }
13459         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
13460         {
13461             VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13462             const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *)in_header;
13463             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
13464             out_ext->pNext = NULL;
13465             out_ext->shadingRateType = in_ext->shadingRateType;
13466             out_ext->shadingRate = in_ext->shadingRate;
13467             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
13468             out_header->pNext = (void *)out_ext;
13469             out_header = (void *)out_ext;
13470             break;
13471         }
13472         case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
13473         {
13474             VkPipelineRenderingCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13475             const VkPipelineRenderingCreateInfo *in_ext = (const VkPipelineRenderingCreateInfo *)in_header;
13476             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
13477             out_ext->pNext = NULL;
13478             out_ext->viewMask = in_ext->viewMask;
13479             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
13480             out_ext->pColorAttachmentFormats = in_ext->pColorAttachmentFormats;
13481             out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
13482             out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
13483             out_header->pNext = (void *)out_ext;
13484             out_header = (void *)out_ext;
13485             break;
13486         }
13487         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
13488         {
13489             VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13490             const VkAttachmentSampleCountInfoAMD *in_ext = (const VkAttachmentSampleCountInfoAMD *)in_header;
13491             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
13492             out_ext->pNext = NULL;
13493             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
13494             out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples;
13495             out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
13496             out_header->pNext = (void *)out_ext;
13497             out_header = (void *)out_ext;
13498             break;
13499         }
13500         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
13501         {
13502             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13503             const VkMultiviewPerViewAttributesInfoNVX *in_ext = (const VkMultiviewPerViewAttributesInfoNVX *)in_header;
13504             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
13505             out_ext->pNext = NULL;
13506             out_ext->perViewAttributes = in_ext->perViewAttributes;
13507             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
13508             out_header->pNext = (void *)out_ext;
13509             out_header = (void *)out_ext;
13510             break;
13511         }
13512         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
13513         {
13514             VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13515             const VkGraphicsPipelineLibraryCreateInfoEXT *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT *)in_header;
13516             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
13517             out_ext->pNext = NULL;
13518             out_ext->flags = in_ext->flags;
13519             out_header->pNext = (void *)out_ext;
13520             out_header = (void *)out_ext;
13521             break;
13522         }
13523         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
13524         {
13525             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13526             const VkPipelineRobustnessCreateInfoEXT *in_ext = (const VkPipelineRobustnessCreateInfoEXT *)in_header;
13527             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
13528             out_ext->pNext = NULL;
13529             out_ext->storageBuffers = in_ext->storageBuffers;
13530             out_ext->uniformBuffers = in_ext->uniformBuffers;
13531             out_ext->vertexInputs = in_ext->vertexInputs;
13532             out_ext->images = in_ext->images;
13533             out_header->pNext = (void *)out_ext;
13534             out_header = (void *)out_ext;
13535             break;
13536         }
13537         default:
13538             FIXME("Unhandled sType %u.", in_header->sType);
13539             break;
13540         }
13541     }
13542 }
13543 #endif /* USE_STRUCT_CONVERSION */
13544
13545 #if defined(USE_STRUCT_CONVERSION)
13546 static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, VkGraphicsPipelineCreateInfo *out)
13547 {
13548     const VkBaseInStructure *in_header;
13549     VkBaseOutStructure *out_header = (void *)out;
13550
13551     if (!in) return;
13552
13553     out->sType = in->sType;
13554     out->pNext = NULL;
13555     out->flags = in->flags;
13556     out->stageCount = in->stageCount;
13557     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, in->pStages, in->stageCount);
13558     out->pVertexInputState = convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(ctx, in->pVertexInputState, 1);
13559     out->pInputAssemblyState = convert_VkPipelineInputAssemblyStateCreateInfo_array_win32_to_host(ctx, in->pInputAssemblyState, 1);
13560     out->pTessellationState = convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(ctx, in->pTessellationState, 1);
13561     out->pViewportState = convert_VkPipelineViewportStateCreateInfo_array_win32_to_host(ctx, in->pViewportState, 1);
13562     out->pRasterizationState = convert_VkPipelineRasterizationStateCreateInfo_array_win32_to_host(ctx, in->pRasterizationState, 1);
13563     out->pMultisampleState = convert_VkPipelineMultisampleStateCreateInfo_array_win32_to_host(ctx, in->pMultisampleState, 1);
13564     out->pDepthStencilState = convert_VkPipelineDepthStencilStateCreateInfo_array_win32_to_host(ctx, in->pDepthStencilState, 1);
13565     out->pColorBlendState = convert_VkPipelineColorBlendStateCreateInfo_array_win32_to_host(ctx, in->pColorBlendState, 1);
13566     out->pDynamicState = convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(ctx, in->pDynamicState, 1);
13567     out->layout = in->layout;
13568     out->renderPass = in->renderPass;
13569     out->subpass = in->subpass;
13570     out->basePipelineHandle = in->basePipelineHandle;
13571     out->basePipelineIndex = in->basePipelineIndex;
13572
13573     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
13574     {
13575         switch (in_header->sType)
13576         {
13577         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
13578         {
13579             VkGraphicsPipelineShaderGroupsCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13580             const VkGraphicsPipelineShaderGroupsCreateInfoNV32 *in_ext = (const VkGraphicsPipelineShaderGroupsCreateInfoNV32 *)in_header;
13581             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV;
13582             out_ext->pNext = NULL;
13583             out_ext->groupCount = in_ext->groupCount;
13584             out_ext->pGroups = convert_VkGraphicsShaderGroupCreateInfoNV_array_win32_to_host(ctx, in_ext->pGroups, in_ext->groupCount);
13585             out_ext->pipelineCount = in_ext->pipelineCount;
13586             out_ext->pPipelines = in_ext->pPipelines;
13587             out_header->pNext = (void *)out_ext;
13588             out_header = (void *)out_ext;
13589             break;
13590         }
13591         case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
13592         {
13593             VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13594             const VkPipelineDiscardRectangleStateCreateInfoEXT32 *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT32 *)in_header;
13595             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
13596             out_ext->pNext = NULL;
13597             out_ext->flags = in_ext->flags;
13598             out_ext->discardRectangleMode = in_ext->discardRectangleMode;
13599             out_ext->discardRectangleCount = in_ext->discardRectangleCount;
13600             out_ext->pDiscardRectangles = in_ext->pDiscardRectangles;
13601             out_header->pNext = (void *)out_ext;
13602             out_header = (void *)out_ext;
13603             break;
13604         }
13605         case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
13606         {
13607             VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13608             const VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 *)in_header;
13609             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
13610             out_ext->pNext = NULL;
13611             out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable;
13612             out_header->pNext = (void *)out_ext;
13613             out_header = (void *)out_ext;
13614             break;
13615         }
13616         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
13617         {
13618             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13619             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
13620             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
13621             out_ext->pNext = NULL;
13622             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineCreationFeedback, 1);
13623             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
13624             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
13625             out_header->pNext = (void *)out_ext;
13626             out_header = (void *)out_ext;
13627             break;
13628         }
13629         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
13630         {
13631             VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13632             const VkPipelineCompilerControlCreateInfoAMD32 *in_ext = (const VkPipelineCompilerControlCreateInfoAMD32 *)in_header;
13633             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
13634             out_ext->pNext = NULL;
13635             out_ext->compilerControlFlags = in_ext->compilerControlFlags;
13636             out_header->pNext = (void *)out_ext;
13637             out_header = (void *)out_ext;
13638             break;
13639         }
13640         case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
13641         {
13642             VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13643             const VkPipelineLibraryCreateInfoKHR32 *in_ext = (const VkPipelineLibraryCreateInfoKHR32 *)in_header;
13644             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
13645             out_ext->pNext = NULL;
13646             out_ext->libraryCount = in_ext->libraryCount;
13647             out_ext->pLibraries = in_ext->pLibraries;
13648             out_header->pNext = (void *)out_ext;
13649             out_header = (void *)out_ext;
13650             break;
13651         }
13652         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
13653         {
13654             VkPipelineFragmentShadingRateStateCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13655             const VkPipelineFragmentShadingRateStateCreateInfoKHR32 *in_ext = (const VkPipelineFragmentShadingRateStateCreateInfoKHR32 *)in_header;
13656             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR;
13657             out_ext->pNext = NULL;
13658             out_ext->fragmentSize = in_ext->fragmentSize;
13659             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
13660             out_header->pNext = (void *)out_ext;
13661             out_header = (void *)out_ext;
13662             break;
13663         }
13664         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
13665         {
13666             VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13667             const VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 *)in_header;
13668             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
13669             out_ext->pNext = NULL;
13670             out_ext->shadingRateType = in_ext->shadingRateType;
13671             out_ext->shadingRate = in_ext->shadingRate;
13672             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
13673             out_header->pNext = (void *)out_ext;
13674             out_header = (void *)out_ext;
13675             break;
13676         }
13677         case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
13678         {
13679             VkPipelineRenderingCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13680             const VkPipelineRenderingCreateInfo32 *in_ext = (const VkPipelineRenderingCreateInfo32 *)in_header;
13681             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
13682             out_ext->pNext = NULL;
13683             out_ext->viewMask = in_ext->viewMask;
13684             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
13685             out_ext->pColorAttachmentFormats = in_ext->pColorAttachmentFormats;
13686             out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
13687             out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
13688             out_header->pNext = (void *)out_ext;
13689             out_header = (void *)out_ext;
13690             break;
13691         }
13692         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
13693         {
13694             VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13695             const VkAttachmentSampleCountInfoAMD32 *in_ext = (const VkAttachmentSampleCountInfoAMD32 *)in_header;
13696             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
13697             out_ext->pNext = NULL;
13698             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
13699             out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples;
13700             out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
13701             out_header->pNext = (void *)out_ext;
13702             out_header = (void *)out_ext;
13703             break;
13704         }
13705         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
13706         {
13707             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13708             const VkMultiviewPerViewAttributesInfoNVX32 *in_ext = (const VkMultiviewPerViewAttributesInfoNVX32 *)in_header;
13709             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
13710             out_ext->pNext = NULL;
13711             out_ext->perViewAttributes = in_ext->perViewAttributes;
13712             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
13713             out_header->pNext = (void *)out_ext;
13714             out_header = (void *)out_ext;
13715             break;
13716         }
13717         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
13718         {
13719             VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13720             const VkGraphicsPipelineLibraryCreateInfoEXT32 *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT32 *)in_header;
13721             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
13722             out_ext->pNext = NULL;
13723             out_ext->flags = in_ext->flags;
13724             out_header->pNext = (void *)out_ext;
13725             out_header = (void *)out_ext;
13726             break;
13727         }
13728         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
13729         {
13730             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13731             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
13732             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
13733             out_ext->pNext = NULL;
13734             out_ext->storageBuffers = in_ext->storageBuffers;
13735             out_ext->uniformBuffers = in_ext->uniformBuffers;
13736             out_ext->vertexInputs = in_ext->vertexInputs;
13737             out_ext->images = in_ext->images;
13738             out_header->pNext = (void *)out_ext;
13739             out_header = (void *)out_ext;
13740             break;
13741         }
13742         default:
13743             FIXME("Unhandled sType %u.", in_header->sType);
13744             break;
13745         }
13746     }
13747 }
13748 #endif /* USE_STRUCT_CONVERSION */
13749
13750 #if defined(USE_STRUCT_CONVERSION)
13751 static inline void convert_VkGraphicsPipelineCreateInfo_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out)
13752 {
13753     const VkBaseInStructure *in_header;
13754     VkBaseOutStructure *out_header = (void *)out;
13755
13756     if (!in) return;
13757
13758
13759     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
13760     {
13761         switch (in_header->sType)
13762         {
13763         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
13764         {
13765             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
13766             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
13767             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
13768             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, out_ext->pPipelineCreationFeedback, 1);
13769             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, out_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
13770             out_header = (void *)out_ext;
13771             break;
13772         }
13773         default:
13774             break;
13775         }
13776     }
13777 }
13778 #endif /* USE_STRUCT_CONVERSION */
13779
13780 #if !defined(USE_STRUCT_CONVERSION)
13781 static inline const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, uint32_t count)
13782 {
13783     VkGraphicsPipelineCreateInfo *out;
13784     unsigned int i;
13785
13786     if (!in || !count) return NULL;
13787
13788     out = conversion_context_alloc(ctx, count * sizeof(*out));
13789     for (i = 0; i < count; i++)
13790     {
13791         convert_VkGraphicsPipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
13792     }
13793
13794     return out;
13795 }
13796 #endif /* USE_STRUCT_CONVERSION */
13797
13798 #if defined(USE_STRUCT_CONVERSION)
13799 static inline const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, uint32_t count)
13800 {
13801     VkGraphicsPipelineCreateInfo *out;
13802     unsigned int i;
13803
13804     if (!in || !count) return NULL;
13805
13806     out = conversion_context_alloc(ctx, count * sizeof(*out));
13807     for (i = 0; i < count; i++)
13808     {
13809         convert_VkGraphicsPipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
13810     }
13811
13812     return out;
13813 }
13814 #endif /* USE_STRUCT_CONVERSION */
13815
13816 #if defined(USE_STRUCT_CONVERSION)
13817 static inline void convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out, uint32_t count)
13818 {
13819     unsigned int i;
13820
13821     if (!in) return;
13822
13823     for (i = 0; i < count; i++)
13824     {
13825         convert_VkGraphicsPipelineCreateInfo_host_to_win32(&in[i], &out[i]);
13826     }
13827 }
13828 #endif /* USE_STRUCT_CONVERSION */
13829
13830 #if defined(USE_STRUCT_CONVERSION)
13831 static inline void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo32 *in, VkImageCreateInfo *out)
13832 {
13833     const VkBaseInStructure *in_header;
13834     VkBaseOutStructure *out_header = (void *)out;
13835
13836     if (!in) return;
13837
13838     out->sType = in->sType;
13839     out->pNext = NULL;
13840     out->flags = in->flags;
13841     out->imageType = in->imageType;
13842     out->format = in->format;
13843     out->extent = in->extent;
13844     out->mipLevels = in->mipLevels;
13845     out->arrayLayers = in->arrayLayers;
13846     out->samples = in->samples;
13847     out->tiling = in->tiling;
13848     out->usage = in->usage;
13849     out->sharingMode = in->sharingMode;
13850     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
13851     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
13852     out->initialLayout = in->initialLayout;
13853
13854     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
13855     {
13856         switch (in_header->sType)
13857         {
13858         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
13859         {
13860             VkDedicatedAllocationImageCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13861             const VkDedicatedAllocationImageCreateInfoNV32 *in_ext = (const VkDedicatedAllocationImageCreateInfoNV32 *)in_header;
13862             out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV;
13863             out_ext->pNext = NULL;
13864             out_ext->dedicatedAllocation = in_ext->dedicatedAllocation;
13865             out_header->pNext = (void *)out_ext;
13866             out_header = (void *)out_ext;
13867             break;
13868         }
13869         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
13870         {
13871             VkExternalMemoryImageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13872             const VkExternalMemoryImageCreateInfo32 *in_ext = (const VkExternalMemoryImageCreateInfo32 *)in_header;
13873             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
13874             out_ext->pNext = NULL;
13875             out_ext->handleTypes = in_ext->handleTypes;
13876             out_header->pNext = (void *)out_ext;
13877             out_header = (void *)out_ext;
13878             break;
13879         }
13880         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
13881         {
13882             VkImageSwapchainCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13883             const VkImageSwapchainCreateInfoKHR32 *in_ext = (const VkImageSwapchainCreateInfoKHR32 *)in_header;
13884             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR;
13885             out_ext->pNext = NULL;
13886             out_ext->swapchain = in_ext->swapchain;
13887             out_header->pNext = (void *)out_ext;
13888             out_header = (void *)out_ext;
13889             break;
13890         }
13891         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
13892         {
13893             VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13894             const VkImageFormatListCreateInfo32 *in_ext = (const VkImageFormatListCreateInfo32 *)in_header;
13895             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
13896             out_ext->pNext = NULL;
13897             out_ext->viewFormatCount = in_ext->viewFormatCount;
13898             out_ext->pViewFormats = in_ext->pViewFormats;
13899             out_header->pNext = (void *)out_ext;
13900             out_header = (void *)out_ext;
13901             break;
13902         }
13903         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
13904         {
13905             VkImageStencilUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13906             const VkImageStencilUsageCreateInfo32 *in_ext = (const VkImageStencilUsageCreateInfo32 *)in_header;
13907             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO;
13908             out_ext->pNext = NULL;
13909             out_ext->stencilUsage = in_ext->stencilUsage;
13910             out_header->pNext = (void *)out_ext;
13911             out_header = (void *)out_ext;
13912             break;
13913         }
13914         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
13915         {
13916             VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13917             const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
13918             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
13919             out_ext->pNext = NULL;
13920             out_ext->flags = in_ext->flags;
13921             out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
13922             out_ext->pFixedRateFlags = in_ext->pFixedRateFlags;
13923             out_header->pNext = (void *)out_ext;
13924             out_header = (void *)out_ext;
13925             break;
13926         }
13927         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
13928         {
13929             VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13930             const VkOpticalFlowImageFormatInfoNV32 *in_ext = (const VkOpticalFlowImageFormatInfoNV32 *)in_header;
13931             out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV;
13932             out_ext->pNext = NULL;
13933             out_ext->usage = in_ext->usage;
13934             out_header->pNext = (void *)out_ext;
13935             out_header = (void *)out_ext;
13936             break;
13937         }
13938         default:
13939             FIXME("Unhandled sType %u.", in_header->sType);
13940             break;
13941         }
13942     }
13943 }
13944 #endif /* USE_STRUCT_CONVERSION */
13945
13946 #if defined(USE_STRUCT_CONVERSION)
13947 static inline void convert_VkImageViewCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageViewCreateInfo32 *in, VkImageViewCreateInfo *out)
13948 {
13949     const VkBaseInStructure *in_header;
13950     VkBaseOutStructure *out_header = (void *)out;
13951
13952     if (!in) return;
13953
13954     out->sType = in->sType;
13955     out->pNext = NULL;
13956     out->flags = in->flags;
13957     out->image = in->image;
13958     out->viewType = in->viewType;
13959     out->format = in->format;
13960     out->components = in->components;
13961     out->subresourceRange = in->subresourceRange;
13962
13963     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
13964     {
13965         switch (in_header->sType)
13966         {
13967         case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
13968         {
13969             VkImageViewUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13970             const VkImageViewUsageCreateInfo32 *in_ext = (const VkImageViewUsageCreateInfo32 *)in_header;
13971             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO;
13972             out_ext->pNext = NULL;
13973             out_ext->usage = in_ext->usage;
13974             out_header->pNext = (void *)out_ext;
13975             out_header = (void *)out_ext;
13976             break;
13977         }
13978         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
13979         {
13980             VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13981             const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header;
13982             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
13983             out_ext->pNext = NULL;
13984             out_ext->conversion = in_ext->conversion;
13985             out_header->pNext = (void *)out_ext;
13986             out_header = (void *)out_ext;
13987             break;
13988         }
13989         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
13990         {
13991             VkImageViewASTCDecodeModeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13992             const VkImageViewASTCDecodeModeEXT32 *in_ext = (const VkImageViewASTCDecodeModeEXT32 *)in_header;
13993             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT;
13994             out_ext->pNext = NULL;
13995             out_ext->decodeMode = in_ext->decodeMode;
13996             out_header->pNext = (void *)out_ext;
13997             out_header = (void *)out_ext;
13998             break;
13999         }
14000         case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
14001         {
14002             VkImageViewMinLodCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14003             const VkImageViewMinLodCreateInfoEXT32 *in_ext = (const VkImageViewMinLodCreateInfoEXT32 *)in_header;
14004             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT;
14005             out_ext->pNext = NULL;
14006             out_ext->minLod = in_ext->minLod;
14007             out_header->pNext = (void *)out_ext;
14008             out_header = (void *)out_ext;
14009             break;
14010         }
14011         case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM:
14012         {
14013             VkImageViewSampleWeightCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14014             const VkImageViewSampleWeightCreateInfoQCOM32 *in_ext = (const VkImageViewSampleWeightCreateInfoQCOM32 *)in_header;
14015             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM;
14016             out_ext->pNext = NULL;
14017             out_ext->filterCenter = in_ext->filterCenter;
14018             out_ext->filterSize = in_ext->filterSize;
14019             out_ext->numPhases = in_ext->numPhases;
14020             out_header->pNext = (void *)out_ext;
14021             out_header = (void *)out_ext;
14022             break;
14023         }
14024         default:
14025             FIXME("Unhandled sType %u.", in_header->sType);
14026             break;
14027         }
14028     }
14029 }
14030 #endif /* USE_STRUCT_CONVERSION */
14031
14032 #if defined(USE_STRUCT_CONVERSION)
14033 static inline void convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(const VkIndirectCommandsLayoutTokenNV32 *in, VkIndirectCommandsLayoutTokenNV *out)
14034 {
14035     if (!in) return;
14036
14037     out->sType = in->sType;
14038     out->pNext = in->pNext;
14039     out->tokenType = in->tokenType;
14040     out->stream = in->stream;
14041     out->offset = in->offset;
14042     out->vertexBindingUnit = in->vertexBindingUnit;
14043     out->vertexDynamicStride = in->vertexDynamicStride;
14044     out->pushconstantPipelineLayout = in->pushconstantPipelineLayout;
14045     out->pushconstantShaderStageFlags = in->pushconstantShaderStageFlags;
14046     out->pushconstantOffset = in->pushconstantOffset;
14047     out->pushconstantSize = in->pushconstantSize;
14048     out->indirectStateFlags = in->indirectStateFlags;
14049     out->indexTypeCount = in->indexTypeCount;
14050     out->pIndexTypes = in->pIndexTypes;
14051     out->pIndexTypeValues = in->pIndexTypeValues;
14052 }
14053 #endif /* USE_STRUCT_CONVERSION */
14054
14055 #if defined(USE_STRUCT_CONVERSION)
14056 static inline const VkIndirectCommandsLayoutTokenNV *convert_VkIndirectCommandsLayoutTokenNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutTokenNV32 *in, uint32_t count)
14057 {
14058     VkIndirectCommandsLayoutTokenNV *out;
14059     unsigned int i;
14060
14061     if (!in || !count) return NULL;
14062
14063     out = conversion_context_alloc(ctx, count * sizeof(*out));
14064     for (i = 0; i < count; i++)
14065     {
14066         convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(&in[i], &out[i]);
14067     }
14068
14069     return out;
14070 }
14071 #endif /* USE_STRUCT_CONVERSION */
14072
14073 #if defined(USE_STRUCT_CONVERSION)
14074 static inline void convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutCreateInfoNV32 *in, VkIndirectCommandsLayoutCreateInfoNV *out)
14075 {
14076     if (!in) return;
14077
14078     out->sType = in->sType;
14079     out->pNext = in->pNext;
14080     out->flags = in->flags;
14081     out->pipelineBindPoint = in->pipelineBindPoint;
14082     out->tokenCount = in->tokenCount;
14083     out->pTokens = convert_VkIndirectCommandsLayoutTokenNV_array_win32_to_host(ctx, in->pTokens, in->tokenCount);
14084     out->streamCount = in->streamCount;
14085     out->pStreamStrides = in->pStreamStrides;
14086 }
14087 #endif /* USE_STRUCT_CONVERSION */
14088
14089 #if defined(USE_STRUCT_CONVERSION)
14090 static inline void convert_VkApplicationInfo_win32_to_host(const VkApplicationInfo32 *in, VkApplicationInfo *out)
14091 {
14092     if (!in) return;
14093
14094     out->sType = in->sType;
14095     out->pNext = in->pNext;
14096     out->pApplicationName = in->pApplicationName;
14097     out->applicationVersion = in->applicationVersion;
14098     out->pEngineName = in->pEngineName;
14099     out->engineVersion = in->engineVersion;
14100     out->apiVersion = in->apiVersion;
14101 }
14102 #endif /* USE_STRUCT_CONVERSION */
14103
14104 #if defined(USE_STRUCT_CONVERSION)
14105 static inline const VkApplicationInfo *convert_VkApplicationInfo_array_win32_to_host(struct conversion_context *ctx, const VkApplicationInfo32 *in, uint32_t count)
14106 {
14107     VkApplicationInfo *out;
14108     unsigned int i;
14109
14110     if (!in || !count) return NULL;
14111
14112     out = conversion_context_alloc(ctx, count * sizeof(*out));
14113     for (i = 0; i < count; i++)
14114     {
14115         convert_VkApplicationInfo_win32_to_host(&in[i], &out[i]);
14116     }
14117
14118     return out;
14119 }
14120 #endif /* USE_STRUCT_CONVERSION */
14121
14122 #if !defined(USE_STRUCT_CONVERSION)
14123 static inline void convert_VkInstanceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo *in, VkInstanceCreateInfo *out)
14124 {
14125     const VkBaseInStructure *in_header;
14126     VkBaseOutStructure *out_header = (void *)out;
14127
14128     if (!in) return;
14129
14130     out->sType = in->sType;
14131     out->pNext = NULL;
14132     out->flags = in->flags;
14133     out->pApplicationInfo = in->pApplicationInfo;
14134     out->enabledLayerCount = in->enabledLayerCount;
14135     out->ppEnabledLayerNames = in->ppEnabledLayerNames;
14136     out->enabledExtensionCount = in->enabledExtensionCount;
14137     out->ppEnabledExtensionNames = in->ppEnabledExtensionNames;
14138
14139     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
14140     {
14141         switch (in_header->sType)
14142         {
14143         case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
14144             break;
14145         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
14146         {
14147             VkDebugReportCallbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14148             const VkDebugReportCallbackCreateInfoEXT *in_ext = (const VkDebugReportCallbackCreateInfoEXT *)in_header;
14149             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
14150             out_ext->pNext = NULL;
14151             out_ext->flags = in_ext->flags;
14152             out_ext->pfnCallback = in_ext->pfnCallback;
14153             out_ext->pUserData = in_ext->pUserData;
14154             out_header->pNext = (void *)out_ext;
14155             out_header = (void *)out_ext;
14156             break;
14157         }
14158         case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
14159         {
14160             VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14161             const VkValidationFlagsEXT *in_ext = (const VkValidationFlagsEXT *)in_header;
14162             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT;
14163             out_ext->pNext = NULL;
14164             out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount;
14165             out_ext->pDisabledValidationChecks = in_ext->pDisabledValidationChecks;
14166             out_header->pNext = (void *)out_ext;
14167             out_header = (void *)out_ext;
14168             break;
14169         }
14170         case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
14171         {
14172             VkValidationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14173             const VkValidationFeaturesEXT *in_ext = (const VkValidationFeaturesEXT *)in_header;
14174             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT;
14175             out_ext->pNext = NULL;
14176             out_ext->enabledValidationFeatureCount = in_ext->enabledValidationFeatureCount;
14177             out_ext->pEnabledValidationFeatures = in_ext->pEnabledValidationFeatures;
14178             out_ext->disabledValidationFeatureCount = in_ext->disabledValidationFeatureCount;
14179             out_ext->pDisabledValidationFeatures = in_ext->pDisabledValidationFeatures;
14180             out_header->pNext = (void *)out_ext;
14181             out_header = (void *)out_ext;
14182             break;
14183         }
14184         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
14185         {
14186             VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14187             const VkDebugUtilsMessengerCreateInfoEXT *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT *)in_header;
14188             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
14189             out_ext->pNext = NULL;
14190             out_ext->flags = in_ext->flags;
14191             out_ext->messageSeverity = in_ext->messageSeverity;
14192             out_ext->messageType = in_ext->messageType;
14193             out_ext->pfnUserCallback = in_ext->pfnUserCallback;
14194             out_ext->pUserData = in_ext->pUserData;
14195             out_header->pNext = (void *)out_ext;
14196             out_header = (void *)out_ext;
14197             break;
14198         }
14199         default:
14200             FIXME("Unhandled sType %u.", in_header->sType);
14201             break;
14202         }
14203     }
14204 }
14205 #endif /* USE_STRUCT_CONVERSION */
14206
14207 #if defined(USE_STRUCT_CONVERSION)
14208 static inline void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo32 *in, VkInstanceCreateInfo *out)
14209 {
14210     const VkBaseInStructure *in_header;
14211     VkBaseOutStructure *out_header = (void *)out;
14212
14213     if (!in) return;
14214
14215     out->sType = in->sType;
14216     out->pNext = NULL;
14217     out->flags = in->flags;
14218     out->pApplicationInfo = convert_VkApplicationInfo_array_win32_to_host(ctx, in->pApplicationInfo, 1);
14219     out->enabledLayerCount = in->enabledLayerCount;
14220     out->ppEnabledLayerNames = in->ppEnabledLayerNames;
14221     out->enabledExtensionCount = in->enabledExtensionCount;
14222     out->ppEnabledExtensionNames = in->ppEnabledExtensionNames;
14223
14224     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
14225     {
14226         switch (in_header->sType)
14227         {
14228         case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
14229             break;
14230         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
14231         {
14232             VkDebugReportCallbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14233             const VkDebugReportCallbackCreateInfoEXT32 *in_ext = (const VkDebugReportCallbackCreateInfoEXT32 *)in_header;
14234             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
14235             out_ext->pNext = NULL;
14236             out_ext->flags = in_ext->flags;
14237             out_ext->pfnCallback = in_ext->pfnCallback;
14238             out_ext->pUserData = in_ext->pUserData;
14239             out_header->pNext = (void *)out_ext;
14240             out_header = (void *)out_ext;
14241             break;
14242         }
14243         case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
14244         {
14245             VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14246             const VkValidationFlagsEXT32 *in_ext = (const VkValidationFlagsEXT32 *)in_header;
14247             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT;
14248             out_ext->pNext = NULL;
14249             out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount;
14250             out_ext->pDisabledValidationChecks = in_ext->pDisabledValidationChecks;
14251             out_header->pNext = (void *)out_ext;
14252             out_header = (void *)out_ext;
14253             break;
14254         }
14255         case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
14256         {
14257             VkValidationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14258             const VkValidationFeaturesEXT32 *in_ext = (const VkValidationFeaturesEXT32 *)in_header;
14259             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT;
14260             out_ext->pNext = NULL;
14261             out_ext->enabledValidationFeatureCount = in_ext->enabledValidationFeatureCount;
14262             out_ext->pEnabledValidationFeatures = in_ext->pEnabledValidationFeatures;
14263             out_ext->disabledValidationFeatureCount = in_ext->disabledValidationFeatureCount;
14264             out_ext->pDisabledValidationFeatures = in_ext->pDisabledValidationFeatures;
14265             out_header->pNext = (void *)out_ext;
14266             out_header = (void *)out_ext;
14267             break;
14268         }
14269         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
14270         {
14271             VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14272             const VkDebugUtilsMessengerCreateInfoEXT32 *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT32 *)in_header;
14273             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
14274             out_ext->pNext = NULL;
14275             out_ext->flags = in_ext->flags;
14276             out_ext->messageSeverity = in_ext->messageSeverity;
14277             out_ext->messageType = in_ext->messageType;
14278             out_ext->pfnUserCallback = in_ext->pfnUserCallback;
14279             out_ext->pUserData = in_ext->pUserData;
14280             out_header->pNext = (void *)out_ext;
14281             out_header = (void *)out_ext;
14282             break;
14283         }
14284         default:
14285             FIXME("Unhandled sType %u.", in_header->sType);
14286             break;
14287         }
14288     }
14289 }
14290 #endif /* USE_STRUCT_CONVERSION */
14291
14292 #if defined(USE_STRUCT_CONVERSION)
14293 static inline void convert_VkMicromapCreateInfoEXT_win32_to_host(const VkMicromapCreateInfoEXT32 *in, VkMicromapCreateInfoEXT *out)
14294 {
14295     if (!in) return;
14296
14297     out->sType = in->sType;
14298     out->pNext = in->pNext;
14299     out->createFlags = in->createFlags;
14300     out->buffer = in->buffer;
14301     out->offset = in->offset;
14302     out->size = in->size;
14303     out->type = in->type;
14304     out->deviceAddress = in->deviceAddress;
14305 }
14306 #endif /* USE_STRUCT_CONVERSION */
14307
14308 #if defined(USE_STRUCT_CONVERSION)
14309 static inline void convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkOpticalFlowSessionCreateInfoNV32 *in, VkOpticalFlowSessionCreateInfoNV *out)
14310 {
14311     const VkBaseInStructure *in_header;
14312     VkBaseOutStructure *out_header = (void *)out;
14313
14314     if (!in) return;
14315
14316     out->sType = in->sType;
14317     out->pNext = NULL;
14318     out->width = in->width;
14319     out->height = in->height;
14320     out->imageFormat = in->imageFormat;
14321     out->flowVectorFormat = in->flowVectorFormat;
14322     out->costFormat = in->costFormat;
14323     out->outputGridSize = in->outputGridSize;
14324     out->hintGridSize = in->hintGridSize;
14325     out->performanceLevel = in->performanceLevel;
14326     out->flags = in->flags;
14327
14328     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
14329     {
14330         switch (in_header->sType)
14331         {
14332         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV:
14333         {
14334             VkOpticalFlowSessionCreatePrivateDataInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14335             const VkOpticalFlowSessionCreatePrivateDataInfoNV32 *in_ext = (const VkOpticalFlowSessionCreatePrivateDataInfoNV32 *)in_header;
14336             out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV;
14337             out_ext->pNext = NULL;
14338             out_ext->id = in_ext->id;
14339             out_ext->size = in_ext->size;
14340             out_ext->pPrivateData = in_ext->pPrivateData;
14341             out_header->pNext = (void *)out_ext;
14342             out_header = (void *)out_ext;
14343             break;
14344         }
14345         default:
14346             FIXME("Unhandled sType %u.", in_header->sType);
14347             break;
14348         }
14349     }
14350 }
14351 #endif /* USE_STRUCT_CONVERSION */
14352
14353 #if defined(USE_STRUCT_CONVERSION)
14354 static inline void convert_VkPipelineCacheCreateInfo_win32_to_host(const VkPipelineCacheCreateInfo32 *in, VkPipelineCacheCreateInfo *out)
14355 {
14356     if (!in) return;
14357
14358     out->sType = in->sType;
14359     out->pNext = in->pNext;
14360     out->flags = in->flags;
14361     out->initialDataSize = in->initialDataSize;
14362     out->pInitialData = in->pInitialData;
14363 }
14364 #endif /* USE_STRUCT_CONVERSION */
14365
14366 #if defined(USE_STRUCT_CONVERSION)
14367 static inline void convert_VkPipelineLayoutCreateInfo_win32_to_host(const VkPipelineLayoutCreateInfo32 *in, VkPipelineLayoutCreateInfo *out)
14368 {
14369     if (!in) return;
14370
14371     out->sType = in->sType;
14372     out->pNext = in->pNext;
14373     out->flags = in->flags;
14374     out->setLayoutCount = in->setLayoutCount;
14375     out->pSetLayouts = in->pSetLayouts;
14376     out->pushConstantRangeCount = in->pushConstantRangeCount;
14377     out->pPushConstantRanges = in->pPushConstantRanges;
14378 }
14379 #endif /* USE_STRUCT_CONVERSION */
14380
14381 #if defined(USE_STRUCT_CONVERSION)
14382 static inline void convert_VkPrivateDataSlotCreateInfo_win32_to_host(const VkPrivateDataSlotCreateInfo32 *in, VkPrivateDataSlotCreateInfo *out)
14383 {
14384     if (!in) return;
14385
14386     out->sType = in->sType;
14387     out->pNext = in->pNext;
14388     out->flags = in->flags;
14389 }
14390 #endif /* USE_STRUCT_CONVERSION */
14391
14392 #if defined(USE_STRUCT_CONVERSION)
14393 static inline void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkQueryPoolCreateInfo32 *in, VkQueryPoolCreateInfo *out)
14394 {
14395     const VkBaseInStructure *in_header;
14396     VkBaseOutStructure *out_header = (void *)out;
14397
14398     if (!in) return;
14399
14400     out->sType = in->sType;
14401     out->pNext = NULL;
14402     out->flags = in->flags;
14403     out->queryType = in->queryType;
14404     out->queryCount = in->queryCount;
14405     out->pipelineStatistics = in->pipelineStatistics;
14406
14407     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
14408     {
14409         switch (in_header->sType)
14410         {
14411         case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
14412         {
14413             VkQueryPoolPerformanceCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14414             const VkQueryPoolPerformanceCreateInfoKHR32 *in_ext = (const VkQueryPoolPerformanceCreateInfoKHR32 *)in_header;
14415             out_ext->sType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR;
14416             out_ext->pNext = NULL;
14417             out_ext->queueFamilyIndex = in_ext->queueFamilyIndex;
14418             out_ext->counterIndexCount = in_ext->counterIndexCount;
14419             out_ext->pCounterIndices = in_ext->pCounterIndices;
14420             out_header->pNext = (void *)out_ext;
14421             out_header = (void *)out_ext;
14422             break;
14423         }
14424         case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
14425         {
14426             VkQueryPoolPerformanceQueryCreateInfoINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14427             const VkQueryPoolPerformanceQueryCreateInfoINTEL32 *in_ext = (const VkQueryPoolPerformanceQueryCreateInfoINTEL32 *)in_header;
14428             out_ext->sType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL;
14429             out_ext->pNext = NULL;
14430             out_ext->performanceCountersSampling = in_ext->performanceCountersSampling;
14431             out_header->pNext = (void *)out_ext;
14432             out_header = (void *)out_ext;
14433             break;
14434         }
14435         default:
14436             FIXME("Unhandled sType %u.", in_header->sType);
14437             break;
14438         }
14439     }
14440 }
14441 #endif /* USE_STRUCT_CONVERSION */
14442
14443 #if defined(USE_STRUCT_CONVERSION)
14444 static inline void convert_VkRayTracingShaderGroupCreateInfoKHR_win32_to_host(const VkRayTracingShaderGroupCreateInfoKHR32 *in, VkRayTracingShaderGroupCreateInfoKHR *out)
14445 {
14446     if (!in) return;
14447
14448     out->sType = in->sType;
14449     out->pNext = in->pNext;
14450     out->type = in->type;
14451     out->generalShader = in->generalShader;
14452     out->closestHitShader = in->closestHitShader;
14453     out->anyHitShader = in->anyHitShader;
14454     out->intersectionShader = in->intersectionShader;
14455     out->pShaderGroupCaptureReplayHandle = in->pShaderGroupCaptureReplayHandle;
14456 }
14457 #endif /* USE_STRUCT_CONVERSION */
14458
14459 #if defined(USE_STRUCT_CONVERSION)
14460 static inline const VkRayTracingShaderGroupCreateInfoKHR *convert_VkRayTracingShaderGroupCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingShaderGroupCreateInfoKHR32 *in, uint32_t count)
14461 {
14462     VkRayTracingShaderGroupCreateInfoKHR *out;
14463     unsigned int i;
14464
14465     if (!in || !count) return NULL;
14466
14467     out = conversion_context_alloc(ctx, count * sizeof(*out));
14468     for (i = 0; i < count; i++)
14469     {
14470         convert_VkRayTracingShaderGroupCreateInfoKHR_win32_to_host(&in[i], &out[i]);
14471     }
14472
14473     return out;
14474 }
14475 #endif /* USE_STRUCT_CONVERSION */
14476
14477 #if defined(USE_STRUCT_CONVERSION)
14478 static inline void convert_VkPipelineLibraryCreateInfoKHR_win32_to_host(const VkPipelineLibraryCreateInfoKHR32 *in, VkPipelineLibraryCreateInfoKHR *out)
14479 {
14480     if (!in) return;
14481
14482     out->sType = in->sType;
14483     out->pNext = in->pNext;
14484     out->libraryCount = in->libraryCount;
14485     out->pLibraries = in->pLibraries;
14486 }
14487 #endif /* USE_STRUCT_CONVERSION */
14488
14489 #if defined(USE_STRUCT_CONVERSION)
14490 static inline const VkPipelineLibraryCreateInfoKHR *convert_VkPipelineLibraryCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineLibraryCreateInfoKHR32 *in, uint32_t count)
14491 {
14492     VkPipelineLibraryCreateInfoKHR *out;
14493     unsigned int i;
14494
14495     if (!in || !count) return NULL;
14496
14497     out = conversion_context_alloc(ctx, count * sizeof(*out));
14498     for (i = 0; i < count; i++)
14499     {
14500         convert_VkPipelineLibraryCreateInfoKHR_win32_to_host(&in[i], &out[i]);
14501     }
14502
14503     return out;
14504 }
14505 #endif /* USE_STRUCT_CONVERSION */
14506
14507 #if defined(USE_STRUCT_CONVERSION)
14508 static inline void convert_VkRayTracingPipelineInterfaceCreateInfoKHR_win32_to_host(const VkRayTracingPipelineInterfaceCreateInfoKHR32 *in, VkRayTracingPipelineInterfaceCreateInfoKHR *out)
14509 {
14510     if (!in) return;
14511
14512     out->sType = in->sType;
14513     out->pNext = in->pNext;
14514     out->maxPipelineRayPayloadSize = in->maxPipelineRayPayloadSize;
14515     out->maxPipelineRayHitAttributeSize = in->maxPipelineRayHitAttributeSize;
14516 }
14517 #endif /* USE_STRUCT_CONVERSION */
14518
14519 #if defined(USE_STRUCT_CONVERSION)
14520 static inline const VkRayTracingPipelineInterfaceCreateInfoKHR *convert_VkRayTracingPipelineInterfaceCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineInterfaceCreateInfoKHR32 *in, uint32_t count)
14521 {
14522     VkRayTracingPipelineInterfaceCreateInfoKHR *out;
14523     unsigned int i;
14524
14525     if (!in || !count) return NULL;
14526
14527     out = conversion_context_alloc(ctx, count * sizeof(*out));
14528     for (i = 0; i < count; i++)
14529     {
14530         convert_VkRayTracingPipelineInterfaceCreateInfoKHR_win32_to_host(&in[i], &out[i]);
14531     }
14532
14533     return out;
14534 }
14535 #endif /* USE_STRUCT_CONVERSION */
14536
14537 #if !defined(USE_STRUCT_CONVERSION)
14538 static inline void convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, VkRayTracingPipelineCreateInfoKHR *out)
14539 {
14540     if (!in) return;
14541
14542     out->sType = in->sType;
14543     out->pNext = in->pNext;
14544     out->flags = in->flags;
14545     out->stageCount = in->stageCount;
14546     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
14547     out->groupCount = in->groupCount;
14548     out->pGroups = in->pGroups;
14549     out->maxPipelineRayRecursionDepth = in->maxPipelineRayRecursionDepth;
14550     out->pLibraryInfo = in->pLibraryInfo;
14551     out->pLibraryInterface = in->pLibraryInterface;
14552     out->pDynamicState = in->pDynamicState;
14553     out->layout = in->layout;
14554     out->basePipelineHandle = in->basePipelineHandle;
14555     out->basePipelineIndex = in->basePipelineIndex;
14556 }
14557 #endif /* USE_STRUCT_CONVERSION */
14558
14559 #if defined(USE_STRUCT_CONVERSION)
14560 static inline void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, VkRayTracingPipelineCreateInfoKHR *out)
14561 {
14562     const VkBaseInStructure *in_header;
14563     VkBaseOutStructure *out_header = (void *)out;
14564
14565     if (!in) return;
14566
14567     out->sType = in->sType;
14568     out->pNext = NULL;
14569     out->flags = in->flags;
14570     out->stageCount = in->stageCount;
14571     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, in->pStages, in->stageCount);
14572     out->groupCount = in->groupCount;
14573     out->pGroups = convert_VkRayTracingShaderGroupCreateInfoKHR_array_win32_to_host(ctx, in->pGroups, in->groupCount);
14574     out->maxPipelineRayRecursionDepth = in->maxPipelineRayRecursionDepth;
14575     out->pLibraryInfo = convert_VkPipelineLibraryCreateInfoKHR_array_win32_to_host(ctx, in->pLibraryInfo, 1);
14576     out->pLibraryInterface = convert_VkRayTracingPipelineInterfaceCreateInfoKHR_array_win32_to_host(ctx, in->pLibraryInterface, 1);
14577     out->pDynamicState = convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(ctx, in->pDynamicState, 1);
14578     out->layout = in->layout;
14579     out->basePipelineHandle = in->basePipelineHandle;
14580     out->basePipelineIndex = in->basePipelineIndex;
14581
14582     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
14583     {
14584         switch (in_header->sType)
14585         {
14586         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
14587         {
14588             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14589             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
14590             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
14591             out_ext->pNext = NULL;
14592             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineCreationFeedback, 1);
14593             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
14594             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
14595             out_header->pNext = (void *)out_ext;
14596             out_header = (void *)out_ext;
14597             break;
14598         }
14599         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
14600         {
14601             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14602             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
14603             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
14604             out_ext->pNext = NULL;
14605             out_ext->storageBuffers = in_ext->storageBuffers;
14606             out_ext->uniformBuffers = in_ext->uniformBuffers;
14607             out_ext->vertexInputs = in_ext->vertexInputs;
14608             out_ext->images = in_ext->images;
14609             out_header->pNext = (void *)out_ext;
14610             out_header = (void *)out_ext;
14611             break;
14612         }
14613         default:
14614             FIXME("Unhandled sType %u.", in_header->sType);
14615             break;
14616         }
14617     }
14618 }
14619 #endif /* USE_STRUCT_CONVERSION */
14620
14621 #if defined(USE_STRUCT_CONVERSION)
14622 static inline void convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out)
14623 {
14624     const VkBaseInStructure *in_header;
14625     VkBaseOutStructure *out_header = (void *)out;
14626
14627     if (!in) return;
14628
14629
14630     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
14631     {
14632         switch (in_header->sType)
14633         {
14634         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
14635         {
14636             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
14637             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
14638             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
14639             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, out_ext->pPipelineCreationFeedback, 1);
14640             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, out_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
14641             out_header = (void *)out_ext;
14642             break;
14643         }
14644         default:
14645             break;
14646         }
14647     }
14648 }
14649 #endif /* USE_STRUCT_CONVERSION */
14650
14651 #if !defined(USE_STRUCT_CONVERSION)
14652 static inline const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, uint32_t count)
14653 {
14654     VkRayTracingPipelineCreateInfoKHR *out;
14655     unsigned int i;
14656
14657     if (!in || !count) return NULL;
14658
14659     out = conversion_context_alloc(ctx, count * sizeof(*out));
14660     for (i = 0; i < count; i++)
14661     {
14662         convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(ctx, &in[i], &out[i]);
14663     }
14664
14665     return out;
14666 }
14667 #endif /* USE_STRUCT_CONVERSION */
14668
14669 #if defined(USE_STRUCT_CONVERSION)
14670 static inline const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, uint32_t count)
14671 {
14672     VkRayTracingPipelineCreateInfoKHR *out;
14673     unsigned int i;
14674
14675     if (!in || !count) return NULL;
14676
14677     out = conversion_context_alloc(ctx, count * sizeof(*out));
14678     for (i = 0; i < count; i++)
14679     {
14680         convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(ctx, &in[i], &out[i]);
14681     }
14682
14683     return out;
14684 }
14685 #endif /* USE_STRUCT_CONVERSION */
14686
14687 #if defined(USE_STRUCT_CONVERSION)
14688 static inline void convert_VkRayTracingPipelineCreateInfoKHR_array_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out, uint32_t count)
14689 {
14690     unsigned int i;
14691
14692     if (!in) return;
14693
14694     for (i = 0; i < count; i++)
14695     {
14696         convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(&in[i], &out[i]);
14697     }
14698 }
14699 #endif /* USE_STRUCT_CONVERSION */
14700
14701 #if defined(USE_STRUCT_CONVERSION)
14702 static inline void convert_VkRayTracingShaderGroupCreateInfoNV_win32_to_host(const VkRayTracingShaderGroupCreateInfoNV32 *in, VkRayTracingShaderGroupCreateInfoNV *out)
14703 {
14704     if (!in) return;
14705
14706     out->sType = in->sType;
14707     out->pNext = in->pNext;
14708     out->type = in->type;
14709     out->generalShader = in->generalShader;
14710     out->closestHitShader = in->closestHitShader;
14711     out->anyHitShader = in->anyHitShader;
14712     out->intersectionShader = in->intersectionShader;
14713 }
14714 #endif /* USE_STRUCT_CONVERSION */
14715
14716 #if defined(USE_STRUCT_CONVERSION)
14717 static inline const VkRayTracingShaderGroupCreateInfoNV *convert_VkRayTracingShaderGroupCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingShaderGroupCreateInfoNV32 *in, uint32_t count)
14718 {
14719     VkRayTracingShaderGroupCreateInfoNV *out;
14720     unsigned int i;
14721
14722     if (!in || !count) return NULL;
14723
14724     out = conversion_context_alloc(ctx, count * sizeof(*out));
14725     for (i = 0; i < count; i++)
14726     {
14727         convert_VkRayTracingShaderGroupCreateInfoNV_win32_to_host(&in[i], &out[i]);
14728     }
14729
14730     return out;
14731 }
14732 #endif /* USE_STRUCT_CONVERSION */
14733
14734 #if !defined(USE_STRUCT_CONVERSION)
14735 static inline void convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, VkRayTracingPipelineCreateInfoNV *out)
14736 {
14737     if (!in) return;
14738
14739     out->sType = in->sType;
14740     out->pNext = in->pNext;
14741     out->flags = in->flags;
14742     out->stageCount = in->stageCount;
14743     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
14744     out->groupCount = in->groupCount;
14745     out->pGroups = in->pGroups;
14746     out->maxRecursionDepth = in->maxRecursionDepth;
14747     out->layout = in->layout;
14748     out->basePipelineHandle = in->basePipelineHandle;
14749     out->basePipelineIndex = in->basePipelineIndex;
14750 }
14751 #endif /* USE_STRUCT_CONVERSION */
14752
14753 #if defined(USE_STRUCT_CONVERSION)
14754 static inline void convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, VkRayTracingPipelineCreateInfoNV *out)
14755 {
14756     const VkBaseInStructure *in_header;
14757     VkBaseOutStructure *out_header = (void *)out;
14758
14759     if (!in) return;
14760
14761     out->sType = in->sType;
14762     out->pNext = NULL;
14763     out->flags = in->flags;
14764     out->stageCount = in->stageCount;
14765     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, in->pStages, in->stageCount);
14766     out->groupCount = in->groupCount;
14767     out->pGroups = convert_VkRayTracingShaderGroupCreateInfoNV_array_win32_to_host(ctx, in->pGroups, in->groupCount);
14768     out->maxRecursionDepth = in->maxRecursionDepth;
14769     out->layout = in->layout;
14770     out->basePipelineHandle = in->basePipelineHandle;
14771     out->basePipelineIndex = in->basePipelineIndex;
14772
14773     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
14774     {
14775         switch (in_header->sType)
14776         {
14777         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
14778         {
14779             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14780             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
14781             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
14782             out_ext->pNext = NULL;
14783             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineCreationFeedback, 1);
14784             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
14785             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
14786             out_header->pNext = (void *)out_ext;
14787             out_header = (void *)out_ext;
14788             break;
14789         }
14790         default:
14791             FIXME("Unhandled sType %u.", in_header->sType);
14792             break;
14793         }
14794     }
14795 }
14796 #endif /* USE_STRUCT_CONVERSION */
14797
14798 #if defined(USE_STRUCT_CONVERSION)
14799 static inline void convert_VkRayTracingPipelineCreateInfoNV_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out)
14800 {
14801     const VkBaseInStructure *in_header;
14802     VkBaseOutStructure *out_header = (void *)out;
14803
14804     if (!in) return;
14805
14806
14807     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
14808     {
14809         switch (in_header->sType)
14810         {
14811         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
14812         {
14813             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
14814             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
14815             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
14816             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, out_ext->pPipelineCreationFeedback, 1);
14817             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, out_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
14818             out_header = (void *)out_ext;
14819             break;
14820         }
14821         default:
14822             break;
14823         }
14824     }
14825 }
14826 #endif /* USE_STRUCT_CONVERSION */
14827
14828 #if !defined(USE_STRUCT_CONVERSION)
14829 static inline const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, uint32_t count)
14830 {
14831     VkRayTracingPipelineCreateInfoNV *out;
14832     unsigned int i;
14833
14834     if (!in || !count) return NULL;
14835
14836     out = conversion_context_alloc(ctx, count * sizeof(*out));
14837     for (i = 0; i < count; i++)
14838     {
14839         convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]);
14840     }
14841
14842     return out;
14843 }
14844 #endif /* USE_STRUCT_CONVERSION */
14845
14846 #if defined(USE_STRUCT_CONVERSION)
14847 static inline const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, uint32_t count)
14848 {
14849     VkRayTracingPipelineCreateInfoNV *out;
14850     unsigned int i;
14851
14852     if (!in || !count) return NULL;
14853
14854     out = conversion_context_alloc(ctx, count * sizeof(*out));
14855     for (i = 0; i < count; i++)
14856     {
14857         convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]);
14858     }
14859
14860     return out;
14861 }
14862 #endif /* USE_STRUCT_CONVERSION */
14863
14864 #if defined(USE_STRUCT_CONVERSION)
14865 static inline void convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out, uint32_t count)
14866 {
14867     unsigned int i;
14868
14869     if (!in) return;
14870
14871     for (i = 0; i < count; i++)
14872     {
14873         convert_VkRayTracingPipelineCreateInfoNV_host_to_win32(&in[i], &out[i]);
14874     }
14875 }
14876 #endif /* USE_STRUCT_CONVERSION */
14877
14878 #if defined(USE_STRUCT_CONVERSION)
14879 static inline void convert_VkRenderPassCreateInfo_win32_to_host(struct conversion_context *ctx, const VkRenderPassCreateInfo32 *in, VkRenderPassCreateInfo *out)
14880 {
14881     const VkBaseInStructure *in_header;
14882     VkBaseOutStructure *out_header = (void *)out;
14883
14884     if (!in) return;
14885
14886     out->sType = in->sType;
14887     out->pNext = NULL;
14888     out->flags = in->flags;
14889     out->attachmentCount = in->attachmentCount;
14890     out->pAttachments = in->pAttachments;
14891     out->subpassCount = in->subpassCount;
14892     out->pSubpasses = in->pSubpasses;
14893     out->dependencyCount = in->dependencyCount;
14894     out->pDependencies = in->pDependencies;
14895
14896     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
14897     {
14898         switch (in_header->sType)
14899         {
14900         case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
14901         {
14902             VkRenderPassMultiviewCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14903             const VkRenderPassMultiviewCreateInfo32 *in_ext = (const VkRenderPassMultiviewCreateInfo32 *)in_header;
14904             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO;
14905             out_ext->pNext = NULL;
14906             out_ext->subpassCount = in_ext->subpassCount;
14907             out_ext->pViewMasks = in_ext->pViewMasks;
14908             out_ext->dependencyCount = in_ext->dependencyCount;
14909             out_ext->pViewOffsets = in_ext->pViewOffsets;
14910             out_ext->correlationMaskCount = in_ext->correlationMaskCount;
14911             out_ext->pCorrelationMasks = in_ext->pCorrelationMasks;
14912             out_header->pNext = (void *)out_ext;
14913             out_header = (void *)out_ext;
14914             break;
14915         }
14916         case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
14917         {
14918             VkRenderPassInputAttachmentAspectCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14919             const VkRenderPassInputAttachmentAspectCreateInfo32 *in_ext = (const VkRenderPassInputAttachmentAspectCreateInfo32 *)in_header;
14920             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO;
14921             out_ext->pNext = NULL;
14922             out_ext->aspectReferenceCount = in_ext->aspectReferenceCount;
14923             out_ext->pAspectReferences = in_ext->pAspectReferences;
14924             out_header->pNext = (void *)out_ext;
14925             out_header = (void *)out_ext;
14926             break;
14927         }
14928         case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
14929         {
14930             VkRenderPassFragmentDensityMapCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14931             const VkRenderPassFragmentDensityMapCreateInfoEXT32 *in_ext = (const VkRenderPassFragmentDensityMapCreateInfoEXT32 *)in_header;
14932             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
14933             out_ext->pNext = NULL;
14934             out_ext->fragmentDensityMapAttachment = in_ext->fragmentDensityMapAttachment;
14935             out_header->pNext = (void *)out_ext;
14936             out_header = (void *)out_ext;
14937             break;
14938         }
14939         default:
14940             FIXME("Unhandled sType %u.", in_header->sType);
14941             break;
14942         }
14943     }
14944 }
14945 #endif /* USE_STRUCT_CONVERSION */
14946
14947 #if defined(USE_STRUCT_CONVERSION)
14948 static inline void convert_VkAttachmentDescription2_win32_to_host(struct conversion_context *ctx, const VkAttachmentDescription232 *in, VkAttachmentDescription2 *out)
14949 {
14950     const VkBaseInStructure *in_header;
14951     VkBaseOutStructure *out_header = (void *)out;
14952
14953     if (!in) return;
14954
14955     out->sType = in->sType;
14956     out->pNext = NULL;
14957     out->flags = in->flags;
14958     out->format = in->format;
14959     out->samples = in->samples;
14960     out->loadOp = in->loadOp;
14961     out->storeOp = in->storeOp;
14962     out->stencilLoadOp = in->stencilLoadOp;
14963     out->stencilStoreOp = in->stencilStoreOp;
14964     out->initialLayout = in->initialLayout;
14965     out->finalLayout = in->finalLayout;
14966
14967     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
14968     {
14969         switch (in_header->sType)
14970         {
14971         case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
14972         {
14973             VkAttachmentDescriptionStencilLayout *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14974             const VkAttachmentDescriptionStencilLayout32 *in_ext = (const VkAttachmentDescriptionStencilLayout32 *)in_header;
14975             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT;
14976             out_ext->pNext = NULL;
14977             out_ext->stencilInitialLayout = in_ext->stencilInitialLayout;
14978             out_ext->stencilFinalLayout = in_ext->stencilFinalLayout;
14979             out_header->pNext = (void *)out_ext;
14980             out_header = (void *)out_ext;
14981             break;
14982         }
14983         default:
14984             FIXME("Unhandled sType %u.", in_header->sType);
14985             break;
14986         }
14987     }
14988 }
14989 #endif /* USE_STRUCT_CONVERSION */
14990
14991 #if defined(USE_STRUCT_CONVERSION)
14992 static inline const VkAttachmentDescription2 *convert_VkAttachmentDescription2_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentDescription232 *in, uint32_t count)
14993 {
14994     VkAttachmentDescription2 *out;
14995     unsigned int i;
14996
14997     if (!in || !count) return NULL;
14998
14999     out = conversion_context_alloc(ctx, count * sizeof(*out));
15000     for (i = 0; i < count; i++)
15001     {
15002         convert_VkAttachmentDescription2_win32_to_host(ctx, &in[i], &out[i]);
15003     }
15004
15005     return out;
15006 }
15007 #endif /* USE_STRUCT_CONVERSION */
15008
15009 #if defined(USE_STRUCT_CONVERSION)
15010 static inline void convert_VkAttachmentReference2_win32_to_host(struct conversion_context *ctx, const VkAttachmentReference232 *in, VkAttachmentReference2 *out)
15011 {
15012     const VkBaseInStructure *in_header;
15013     VkBaseOutStructure *out_header = (void *)out;
15014
15015     if (!in) return;
15016
15017     out->sType = in->sType;
15018     out->pNext = NULL;
15019     out->attachment = in->attachment;
15020     out->layout = in->layout;
15021     out->aspectMask = in->aspectMask;
15022
15023     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
15024     {
15025         switch (in_header->sType)
15026         {
15027         case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
15028         {
15029             VkAttachmentReferenceStencilLayout *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15030             const VkAttachmentReferenceStencilLayout32 *in_ext = (const VkAttachmentReferenceStencilLayout32 *)in_header;
15031             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT;
15032             out_ext->pNext = NULL;
15033             out_ext->stencilLayout = in_ext->stencilLayout;
15034             out_header->pNext = (void *)out_ext;
15035             out_header = (void *)out_ext;
15036             break;
15037         }
15038         default:
15039             FIXME("Unhandled sType %u.", in_header->sType);
15040             break;
15041         }
15042     }
15043 }
15044 #endif /* USE_STRUCT_CONVERSION */
15045
15046 #if defined(USE_STRUCT_CONVERSION)
15047 static inline const VkAttachmentReference2 *convert_VkAttachmentReference2_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentReference232 *in, uint32_t count)
15048 {
15049     VkAttachmentReference2 *out;
15050     unsigned int i;
15051
15052     if (!in || !count) return NULL;
15053
15054     out = conversion_context_alloc(ctx, count * sizeof(*out));
15055     for (i = 0; i < count; i++)
15056     {
15057         convert_VkAttachmentReference2_win32_to_host(ctx, &in[i], &out[i]);
15058     }
15059
15060     return out;
15061 }
15062 #endif /* USE_STRUCT_CONVERSION */
15063
15064 #if defined(USE_STRUCT_CONVERSION)
15065 static inline void convert_VkSubpassDescription2_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription232 *in, VkSubpassDescription2 *out)
15066 {
15067     const VkBaseInStructure *in_header;
15068     VkBaseOutStructure *out_header = (void *)out;
15069
15070     if (!in) return;
15071
15072     out->sType = in->sType;
15073     out->pNext = NULL;
15074     out->flags = in->flags;
15075     out->pipelineBindPoint = in->pipelineBindPoint;
15076     out->viewMask = in->viewMask;
15077     out->inputAttachmentCount = in->inputAttachmentCount;
15078     out->pInputAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, in->pInputAttachments, in->inputAttachmentCount);
15079     out->colorAttachmentCount = in->colorAttachmentCount;
15080     out->pColorAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, in->pColorAttachments, in->colorAttachmentCount);
15081     out->pResolveAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, in->pResolveAttachments, in->colorAttachmentCount);
15082     out->pDepthStencilAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, in->pDepthStencilAttachment, 1);
15083     out->preserveAttachmentCount = in->preserveAttachmentCount;
15084     out->pPreserveAttachments = in->pPreserveAttachments;
15085
15086     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
15087     {
15088         switch (in_header->sType)
15089         {
15090         case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
15091         {
15092             VkSubpassDescriptionDepthStencilResolve *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15093             const VkSubpassDescriptionDepthStencilResolve32 *in_ext = (const VkSubpassDescriptionDepthStencilResolve32 *)in_header;
15094             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
15095             out_ext->pNext = NULL;
15096             out_ext->depthResolveMode = in_ext->depthResolveMode;
15097             out_ext->stencilResolveMode = in_ext->stencilResolveMode;
15098             out_ext->pDepthStencilResolveAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, in_ext->pDepthStencilResolveAttachment, 1);
15099             out_header->pNext = (void *)out_ext;
15100             out_header = (void *)out_ext;
15101             break;
15102         }
15103         case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
15104         {
15105             VkFragmentShadingRateAttachmentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15106             const VkFragmentShadingRateAttachmentInfoKHR32 *in_ext = (const VkFragmentShadingRateAttachmentInfoKHR32 *)in_header;
15107             out_ext->sType = VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
15108             out_ext->pNext = NULL;
15109             out_ext->pFragmentShadingRateAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, in_ext->pFragmentShadingRateAttachment, 1);
15110             out_ext->shadingRateAttachmentTexelSize = in_ext->shadingRateAttachmentTexelSize;
15111             out_header->pNext = (void *)out_ext;
15112             out_header = (void *)out_ext;
15113             break;
15114         }
15115         case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
15116         {
15117             VkMultisampledRenderToSingleSampledInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15118             const VkMultisampledRenderToSingleSampledInfoEXT32 *in_ext = (const VkMultisampledRenderToSingleSampledInfoEXT32 *)in_header;
15119             out_ext->sType = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT;
15120             out_ext->pNext = NULL;
15121             out_ext->multisampledRenderToSingleSampledEnable = in_ext->multisampledRenderToSingleSampledEnable;
15122             out_ext->rasterizationSamples = in_ext->rasterizationSamples;
15123             out_header->pNext = (void *)out_ext;
15124             out_header = (void *)out_ext;
15125             break;
15126         }
15127         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
15128         {
15129             VkRenderPassCreationControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15130             const VkRenderPassCreationControlEXT32 *in_ext = (const VkRenderPassCreationControlEXT32 *)in_header;
15131             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT;
15132             out_ext->pNext = NULL;
15133             out_ext->disallowMerging = in_ext->disallowMerging;
15134             out_header->pNext = (void *)out_ext;
15135             out_header = (void *)out_ext;
15136             break;
15137         }
15138         case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT:
15139         {
15140             VkRenderPassSubpassFeedbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15141             const VkRenderPassSubpassFeedbackCreateInfoEXT32 *in_ext = (const VkRenderPassSubpassFeedbackCreateInfoEXT32 *)in_header;
15142             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT;
15143             out_ext->pNext = NULL;
15144             out_ext->pSubpassFeedback = in_ext->pSubpassFeedback;
15145             out_header->pNext = (void *)out_ext;
15146             out_header = (void *)out_ext;
15147             break;
15148         }
15149         default:
15150             FIXME("Unhandled sType %u.", in_header->sType);
15151             break;
15152         }
15153     }
15154 }
15155 #endif /* USE_STRUCT_CONVERSION */
15156
15157 #if defined(USE_STRUCT_CONVERSION)
15158 static inline const VkSubpassDescription2 *convert_VkSubpassDescription2_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription232 *in, uint32_t count)
15159 {
15160     VkSubpassDescription2 *out;
15161     unsigned int i;
15162
15163     if (!in || !count) return NULL;
15164
15165     out = conversion_context_alloc(ctx, count * sizeof(*out));
15166     for (i = 0; i < count; i++)
15167     {
15168         convert_VkSubpassDescription2_win32_to_host(ctx, &in[i], &out[i]);
15169     }
15170
15171     return out;
15172 }
15173 #endif /* USE_STRUCT_CONVERSION */
15174
15175 #if defined(USE_STRUCT_CONVERSION)
15176 static inline void convert_VkSubpassDependency2_win32_to_host(struct conversion_context *ctx, const VkSubpassDependency232 *in, VkSubpassDependency2 *out)
15177 {
15178     const VkBaseInStructure *in_header;
15179     VkBaseOutStructure *out_header = (void *)out;
15180
15181     if (!in) return;
15182
15183     out->sType = in->sType;
15184     out->pNext = NULL;
15185     out->srcSubpass = in->srcSubpass;
15186     out->dstSubpass = in->dstSubpass;
15187     out->srcStageMask = in->srcStageMask;
15188     out->dstStageMask = in->dstStageMask;
15189     out->srcAccessMask = in->srcAccessMask;
15190     out->dstAccessMask = in->dstAccessMask;
15191     out->dependencyFlags = in->dependencyFlags;
15192     out->viewOffset = in->viewOffset;
15193
15194     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
15195     {
15196         switch (in_header->sType)
15197         {
15198         case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
15199         {
15200             VkMemoryBarrier2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15201             const VkMemoryBarrier232 *in_ext = (const VkMemoryBarrier232 *)in_header;
15202             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2;
15203             out_ext->pNext = NULL;
15204             out_ext->srcStageMask = in_ext->srcStageMask;
15205             out_ext->srcAccessMask = in_ext->srcAccessMask;
15206             out_ext->dstStageMask = in_ext->dstStageMask;
15207             out_ext->dstAccessMask = in_ext->dstAccessMask;
15208             out_header->pNext = (void *)out_ext;
15209             out_header = (void *)out_ext;
15210             break;
15211         }
15212         default:
15213             FIXME("Unhandled sType %u.", in_header->sType);
15214             break;
15215         }
15216     }
15217 }
15218 #endif /* USE_STRUCT_CONVERSION */
15219
15220 #if defined(USE_STRUCT_CONVERSION)
15221 static inline const VkSubpassDependency2 *convert_VkSubpassDependency2_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDependency232 *in, uint32_t count)
15222 {
15223     VkSubpassDependency2 *out;
15224     unsigned int i;
15225
15226     if (!in || !count) return NULL;
15227
15228     out = conversion_context_alloc(ctx, count * sizeof(*out));
15229     for (i = 0; i < count; i++)
15230     {
15231         convert_VkSubpassDependency2_win32_to_host(ctx, &in[i], &out[i]);
15232     }
15233
15234     return out;
15235 }
15236 #endif /* USE_STRUCT_CONVERSION */
15237
15238 #if defined(USE_STRUCT_CONVERSION)
15239 static inline void convert_VkRenderPassCreateInfo2_win32_to_host(struct conversion_context *ctx, const VkRenderPassCreateInfo232 *in, VkRenderPassCreateInfo2 *out)
15240 {
15241     const VkBaseInStructure *in_header;
15242     VkBaseOutStructure *out_header = (void *)out;
15243
15244     if (!in) return;
15245
15246     out->sType = in->sType;
15247     out->pNext = NULL;
15248     out->flags = in->flags;
15249     out->attachmentCount = in->attachmentCount;
15250     out->pAttachments = convert_VkAttachmentDescription2_array_win32_to_host(ctx, in->pAttachments, in->attachmentCount);
15251     out->subpassCount = in->subpassCount;
15252     out->pSubpasses = convert_VkSubpassDescription2_array_win32_to_host(ctx, in->pSubpasses, in->subpassCount);
15253     out->dependencyCount = in->dependencyCount;
15254     out->pDependencies = convert_VkSubpassDependency2_array_win32_to_host(ctx, in->pDependencies, in->dependencyCount);
15255     out->correlatedViewMaskCount = in->correlatedViewMaskCount;
15256     out->pCorrelatedViewMasks = in->pCorrelatedViewMasks;
15257
15258     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
15259     {
15260         switch (in_header->sType)
15261         {
15262         case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
15263         {
15264             VkRenderPassFragmentDensityMapCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15265             const VkRenderPassFragmentDensityMapCreateInfoEXT32 *in_ext = (const VkRenderPassFragmentDensityMapCreateInfoEXT32 *)in_header;
15266             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
15267             out_ext->pNext = NULL;
15268             out_ext->fragmentDensityMapAttachment = in_ext->fragmentDensityMapAttachment;
15269             out_header->pNext = (void *)out_ext;
15270             out_header = (void *)out_ext;
15271             break;
15272         }
15273         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
15274         {
15275             VkRenderPassCreationControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15276             const VkRenderPassCreationControlEXT32 *in_ext = (const VkRenderPassCreationControlEXT32 *)in_header;
15277             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT;
15278             out_ext->pNext = NULL;
15279             out_ext->disallowMerging = in_ext->disallowMerging;
15280             out_header->pNext = (void *)out_ext;
15281             out_header = (void *)out_ext;
15282             break;
15283         }
15284         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT:
15285         {
15286             VkRenderPassCreationFeedbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15287             const VkRenderPassCreationFeedbackCreateInfoEXT32 *in_ext = (const VkRenderPassCreationFeedbackCreateInfoEXT32 *)in_header;
15288             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT;
15289             out_ext->pNext = NULL;
15290             out_ext->pRenderPassFeedback = in_ext->pRenderPassFeedback;
15291             out_header->pNext = (void *)out_ext;
15292             out_header = (void *)out_ext;
15293             break;
15294         }
15295         default:
15296             FIXME("Unhandled sType %u.", in_header->sType);
15297             break;
15298         }
15299     }
15300 }
15301 #endif /* USE_STRUCT_CONVERSION */
15302
15303 #if defined(USE_STRUCT_CONVERSION)
15304 static inline void convert_VkSamplerCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSamplerCreateInfo32 *in, VkSamplerCreateInfo *out)
15305 {
15306     const VkBaseInStructure *in_header;
15307     VkBaseOutStructure *out_header = (void *)out;
15308
15309     if (!in) return;
15310
15311     out->sType = in->sType;
15312     out->pNext = NULL;
15313     out->flags = in->flags;
15314     out->magFilter = in->magFilter;
15315     out->minFilter = in->minFilter;
15316     out->mipmapMode = in->mipmapMode;
15317     out->addressModeU = in->addressModeU;
15318     out->addressModeV = in->addressModeV;
15319     out->addressModeW = in->addressModeW;
15320     out->mipLodBias = in->mipLodBias;
15321     out->anisotropyEnable = in->anisotropyEnable;
15322     out->maxAnisotropy = in->maxAnisotropy;
15323     out->compareEnable = in->compareEnable;
15324     out->compareOp = in->compareOp;
15325     out->minLod = in->minLod;
15326     out->maxLod = in->maxLod;
15327     out->borderColor = in->borderColor;
15328     out->unnormalizedCoordinates = in->unnormalizedCoordinates;
15329
15330     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
15331     {
15332         switch (in_header->sType)
15333         {
15334         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
15335         {
15336             VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15337             const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header;
15338             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
15339             out_ext->pNext = NULL;
15340             out_ext->conversion = in_ext->conversion;
15341             out_header->pNext = (void *)out_ext;
15342             out_header = (void *)out_ext;
15343             break;
15344         }
15345         case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
15346         {
15347             VkSamplerReductionModeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15348             const VkSamplerReductionModeCreateInfo32 *in_ext = (const VkSamplerReductionModeCreateInfo32 *)in_header;
15349             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO;
15350             out_ext->pNext = NULL;
15351             out_ext->reductionMode = in_ext->reductionMode;
15352             out_header->pNext = (void *)out_ext;
15353             out_header = (void *)out_ext;
15354             break;
15355         }
15356         case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
15357         {
15358             VkSamplerCustomBorderColorCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15359             const VkSamplerCustomBorderColorCreateInfoEXT32 *in_ext = (const VkSamplerCustomBorderColorCreateInfoEXT32 *)in_header;
15360             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT;
15361             out_ext->pNext = NULL;
15362             out_ext->customBorderColor = in_ext->customBorderColor;
15363             out_ext->format = in_ext->format;
15364             out_header->pNext = (void *)out_ext;
15365             out_header = (void *)out_ext;
15366             break;
15367         }
15368         case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
15369         {
15370             VkSamplerBorderColorComponentMappingCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15371             const VkSamplerBorderColorComponentMappingCreateInfoEXT32 *in_ext = (const VkSamplerBorderColorComponentMappingCreateInfoEXT32 *)in_header;
15372             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT;
15373             out_ext->pNext = NULL;
15374             out_ext->components = in_ext->components;
15375             out_ext->srgb = in_ext->srgb;
15376             out_header->pNext = (void *)out_ext;
15377             out_header = (void *)out_ext;
15378             break;
15379         }
15380         default:
15381             FIXME("Unhandled sType %u.", in_header->sType);
15382             break;
15383         }
15384     }
15385 }
15386 #endif /* USE_STRUCT_CONVERSION */
15387
15388 #if defined(USE_STRUCT_CONVERSION)
15389 static inline void convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host(const VkSamplerYcbcrConversionCreateInfo32 *in, VkSamplerYcbcrConversionCreateInfo *out)
15390 {
15391     if (!in) return;
15392
15393     out->sType = in->sType;
15394     out->pNext = in->pNext;
15395     out->format = in->format;
15396     out->ycbcrModel = in->ycbcrModel;
15397     out->ycbcrRange = in->ycbcrRange;
15398     out->components = in->components;
15399     out->xChromaOffset = in->xChromaOffset;
15400     out->yChromaOffset = in->yChromaOffset;
15401     out->chromaFilter = in->chromaFilter;
15402     out->forceExplicitReconstruction = in->forceExplicitReconstruction;
15403 }
15404 #endif /* USE_STRUCT_CONVERSION */
15405
15406 #if defined(USE_STRUCT_CONVERSION)
15407 static inline void convert_VkSemaphoreCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSemaphoreCreateInfo32 *in, VkSemaphoreCreateInfo *out)
15408 {
15409     const VkBaseInStructure *in_header;
15410     VkBaseOutStructure *out_header = (void *)out;
15411
15412     if (!in) return;
15413
15414     out->sType = in->sType;
15415     out->pNext = NULL;
15416     out->flags = in->flags;
15417
15418     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
15419     {
15420         switch (in_header->sType)
15421         {
15422         case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
15423         {
15424             VkExportSemaphoreCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15425             const VkExportSemaphoreCreateInfo32 *in_ext = (const VkExportSemaphoreCreateInfo32 *)in_header;
15426             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO;
15427             out_ext->pNext = NULL;
15428             out_ext->handleTypes = in_ext->handleTypes;
15429             out_header->pNext = (void *)out_ext;
15430             out_header = (void *)out_ext;
15431             break;
15432         }
15433         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
15434         {
15435             VkSemaphoreTypeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15436             const VkSemaphoreTypeCreateInfo32 *in_ext = (const VkSemaphoreTypeCreateInfo32 *)in_header;
15437             out_ext->sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
15438             out_ext->pNext = NULL;
15439             out_ext->semaphoreType = in_ext->semaphoreType;
15440             out_ext->initialValue = in_ext->initialValue;
15441             out_header->pNext = (void *)out_ext;
15442             out_header = (void *)out_ext;
15443             break;
15444         }
15445         default:
15446             FIXME("Unhandled sType %u.", in_header->sType);
15447             break;
15448         }
15449     }
15450 }
15451 #endif /* USE_STRUCT_CONVERSION */
15452
15453 #if defined(USE_STRUCT_CONVERSION)
15454 static inline void convert_VkShaderModuleCreateInfo_win32_to_host(struct conversion_context *ctx, const VkShaderModuleCreateInfo32 *in, VkShaderModuleCreateInfo *out)
15455 {
15456     const VkBaseInStructure *in_header;
15457     VkBaseOutStructure *out_header = (void *)out;
15458
15459     if (!in) return;
15460
15461     out->sType = in->sType;
15462     out->pNext = NULL;
15463     out->flags = in->flags;
15464     out->codeSize = in->codeSize;
15465     out->pCode = in->pCode;
15466
15467     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
15468     {
15469         switch (in_header->sType)
15470         {
15471         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
15472         {
15473             VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15474             const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header;
15475             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
15476             out_ext->pNext = NULL;
15477             out_ext->validationCache = in_ext->validationCache;
15478             out_header->pNext = (void *)out_ext;
15479             out_header = (void *)out_ext;
15480             break;
15481         }
15482         default:
15483             FIXME("Unhandled sType %u.", in_header->sType);
15484             break;
15485         }
15486     }
15487 }
15488 #endif /* USE_STRUCT_CONVERSION */
15489
15490 #if !defined(USE_STRUCT_CONVERSION)
15491 static inline void convert_VkSwapchainCreateInfoKHR_win64_to_host(const VkSwapchainCreateInfoKHR *in, VkSwapchainCreateInfoKHR *out)
15492 {
15493     if (!in) return;
15494
15495     out->sType = in->sType;
15496     out->pNext = in->pNext;
15497     out->flags = in->flags;
15498     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
15499     out->minImageCount = in->minImageCount;
15500     out->imageFormat = in->imageFormat;
15501     out->imageColorSpace = in->imageColorSpace;
15502     out->imageExtent = in->imageExtent;
15503     out->imageArrayLayers = in->imageArrayLayers;
15504     out->imageUsage = in->imageUsage;
15505     out->imageSharingMode = in->imageSharingMode;
15506     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
15507     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
15508     out->preTransform = in->preTransform;
15509     out->compositeAlpha = in->compositeAlpha;
15510     out->presentMode = in->presentMode;
15511     out->clipped = in->clipped;
15512     out->oldSwapchain = in->oldSwapchain;
15513 }
15514 #endif /* USE_STRUCT_CONVERSION */
15515
15516 #if defined(USE_STRUCT_CONVERSION)
15517 static inline void convert_VkSwapchainCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkSwapchainCreateInfoKHR32 *in, VkSwapchainCreateInfoKHR *out)
15518 {
15519     const VkBaseInStructure *in_header;
15520     VkBaseOutStructure *out_header = (void *)out;
15521
15522     if (!in) return;
15523
15524     out->sType = in->sType;
15525     out->pNext = NULL;
15526     out->flags = in->flags;
15527     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
15528     out->minImageCount = in->minImageCount;
15529     out->imageFormat = in->imageFormat;
15530     out->imageColorSpace = in->imageColorSpace;
15531     out->imageExtent = in->imageExtent;
15532     out->imageArrayLayers = in->imageArrayLayers;
15533     out->imageUsage = in->imageUsage;
15534     out->imageSharingMode = in->imageSharingMode;
15535     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
15536     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
15537     out->preTransform = in->preTransform;
15538     out->compositeAlpha = in->compositeAlpha;
15539     out->presentMode = in->presentMode;
15540     out->clipped = in->clipped;
15541     out->oldSwapchain = in->oldSwapchain;
15542
15543     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
15544     {
15545         switch (in_header->sType)
15546         {
15547         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
15548         {
15549             VkDeviceGroupSwapchainCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15550             const VkDeviceGroupSwapchainCreateInfoKHR32 *in_ext = (const VkDeviceGroupSwapchainCreateInfoKHR32 *)in_header;
15551             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR;
15552             out_ext->pNext = NULL;
15553             out_ext->modes = in_ext->modes;
15554             out_header->pNext = (void *)out_ext;
15555             out_header = (void *)out_ext;
15556             break;
15557         }
15558         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
15559         {
15560             VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15561             const VkImageFormatListCreateInfo32 *in_ext = (const VkImageFormatListCreateInfo32 *)in_header;
15562             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
15563             out_ext->pNext = NULL;
15564             out_ext->viewFormatCount = in_ext->viewFormatCount;
15565             out_ext->pViewFormats = in_ext->pViewFormats;
15566             out_header->pNext = (void *)out_ext;
15567             out_header = (void *)out_ext;
15568             break;
15569         }
15570         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV:
15571         {
15572             VkSwapchainPresentBarrierCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15573             const VkSwapchainPresentBarrierCreateInfoNV32 *in_ext = (const VkSwapchainPresentBarrierCreateInfoNV32 *)in_header;
15574             out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV;
15575             out_ext->pNext = NULL;
15576             out_ext->presentBarrierEnable = in_ext->presentBarrierEnable;
15577             out_header->pNext = (void *)out_ext;
15578             out_header = (void *)out_ext;
15579             break;
15580         }
15581         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
15582         {
15583             VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15584             const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
15585             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
15586             out_ext->pNext = NULL;
15587             out_ext->flags = in_ext->flags;
15588             out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
15589             out_ext->pFixedRateFlags = in_ext->pFixedRateFlags;
15590             out_header->pNext = (void *)out_ext;
15591             out_header = (void *)out_ext;
15592             break;
15593         }
15594         default:
15595             FIXME("Unhandled sType %u.", in_header->sType);
15596             break;
15597         }
15598     }
15599 }
15600 #endif /* USE_STRUCT_CONVERSION */
15601
15602 #if defined(USE_STRUCT_CONVERSION)
15603 static inline void convert_VkValidationCacheCreateInfoEXT_win32_to_host(const VkValidationCacheCreateInfoEXT32 *in, VkValidationCacheCreateInfoEXT *out)
15604 {
15605     if (!in) return;
15606
15607     out->sType = in->sType;
15608     out->pNext = in->pNext;
15609     out->flags = in->flags;
15610     out->initialDataSize = in->initialDataSize;
15611     out->pInitialData = in->pInitialData;
15612 }
15613 #endif /* USE_STRUCT_CONVERSION */
15614
15615 #if defined(USE_STRUCT_CONVERSION)
15616 static inline void convert_VkWin32SurfaceCreateInfoKHR_win32_to_host(const VkWin32SurfaceCreateInfoKHR32 *in, VkWin32SurfaceCreateInfoKHR *out)
15617 {
15618     if (!in) return;
15619
15620     out->sType = in->sType;
15621     out->pNext = in->pNext;
15622     out->flags = in->flags;
15623     out->hinstance = in->hinstance;
15624     out->hwnd = in->hwnd;
15625 }
15626 #endif /* USE_STRUCT_CONVERSION */
15627
15628 #if !defined(USE_STRUCT_CONVERSION)
15629 static inline void convert_VkDebugMarkerObjectNameInfoEXT_win64_to_host(const VkDebugMarkerObjectNameInfoEXT *in, VkDebugMarkerObjectNameInfoEXT *out)
15630 {
15631     if (!in) return;
15632
15633     out->sType = in->sType;
15634     out->pNext = in->pNext;
15635     out->objectType = in->objectType;
15636     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
15637     out->pObjectName = in->pObjectName;
15638 }
15639 #endif /* USE_STRUCT_CONVERSION */
15640
15641 #if defined(USE_STRUCT_CONVERSION)
15642 static inline void convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host(const VkDebugMarkerObjectNameInfoEXT32 *in, VkDebugMarkerObjectNameInfoEXT *out)
15643 {
15644     if (!in) return;
15645
15646     out->sType = in->sType;
15647     out->pNext = in->pNext;
15648     out->objectType = in->objectType;
15649     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
15650     out->pObjectName = in->pObjectName;
15651 }
15652 #endif /* USE_STRUCT_CONVERSION */
15653
15654 #if !defined(USE_STRUCT_CONVERSION)
15655 static inline void convert_VkDebugMarkerObjectTagInfoEXT_win64_to_host(const VkDebugMarkerObjectTagInfoEXT *in, VkDebugMarkerObjectTagInfoEXT *out)
15656 {
15657     if (!in) return;
15658
15659     out->sType = in->sType;
15660     out->pNext = in->pNext;
15661     out->objectType = in->objectType;
15662     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
15663     out->tagName = in->tagName;
15664     out->tagSize = in->tagSize;
15665     out->pTag = in->pTag;
15666 }
15667 #endif /* USE_STRUCT_CONVERSION */
15668
15669 #if defined(USE_STRUCT_CONVERSION)
15670 static inline void convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host(const VkDebugMarkerObjectTagInfoEXT32 *in, VkDebugMarkerObjectTagInfoEXT *out)
15671 {
15672     if (!in) return;
15673
15674     out->sType = in->sType;
15675     out->pNext = in->pNext;
15676     out->objectType = in->objectType;
15677     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
15678     out->tagName = in->tagName;
15679     out->tagSize = in->tagSize;
15680     out->pTag = in->pTag;
15681 }
15682 #endif /* USE_STRUCT_CONVERSION */
15683
15684 #if defined(USE_STRUCT_CONVERSION)
15685 static inline void convert_VkPhysicalDeviceGroupProperties_win32_to_unwrapped_host(const VkPhysicalDeviceGroupProperties32 *in, VkPhysicalDeviceGroupProperties *out)
15686 {
15687     if (!in) return;
15688
15689     out->sType = in->sType;
15690     out->pNext = in->pNext;
15691 }
15692 #endif /* USE_STRUCT_CONVERSION */
15693
15694 #if defined(USE_STRUCT_CONVERSION)
15695 static inline void convert_VkPhysicalDeviceGroupProperties_unwrapped_host_to_win32(const VkPhysicalDeviceGroupProperties *in, VkPhysicalDeviceGroupProperties32 *out)
15696 {
15697     if (!in) return;
15698
15699     out->physicalDeviceCount = in->physicalDeviceCount;
15700     memcpy(out->physicalDevices, in->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice));
15701     out->subsetAllocation = in->subsetAllocation;
15702 }
15703 #endif /* USE_STRUCT_CONVERSION */
15704
15705 #if defined(USE_STRUCT_CONVERSION)
15706 static inline VkPhysicalDeviceGroupProperties *convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPhysicalDeviceGroupProperties32 *in, uint32_t count)
15707 {
15708     VkPhysicalDeviceGroupProperties *out;
15709     unsigned int i;
15710
15711     if (!in || !count) return NULL;
15712
15713     out = conversion_context_alloc(ctx, count * sizeof(*out));
15714     for (i = 0; i < count; i++)
15715     {
15716         convert_VkPhysicalDeviceGroupProperties_win32_to_unwrapped_host(&in[i], &out[i]);
15717     }
15718
15719     return out;
15720 }
15721 #endif /* USE_STRUCT_CONVERSION */
15722
15723 #if defined(USE_STRUCT_CONVERSION)
15724 static inline void convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(const VkPhysicalDeviceGroupProperties *in, VkPhysicalDeviceGroupProperties32 *out, uint32_t count)
15725 {
15726     unsigned int i;
15727
15728     if (!in) return;
15729
15730     for (i = 0; i < count; i++)
15731     {
15732         convert_VkPhysicalDeviceGroupProperties_unwrapped_host_to_win32(&in[i], &out[i]);
15733     }
15734 }
15735 #endif /* USE_STRUCT_CONVERSION */
15736
15737 #if defined(USE_STRUCT_CONVERSION)
15738 static inline void convert_VkPerformanceCounterKHR_win32_to_host(const VkPerformanceCounterKHR32 *in, VkPerformanceCounterKHR *out)
15739 {
15740     if (!in) return;
15741
15742     out->sType = in->sType;
15743     out->pNext = in->pNext;
15744 }
15745 #endif /* USE_STRUCT_CONVERSION */
15746
15747 #if defined(USE_STRUCT_CONVERSION)
15748 static inline void convert_VkPerformanceCounterKHR_host_to_win32(const VkPerformanceCounterKHR *in, VkPerformanceCounterKHR32 *out)
15749 {
15750     if (!in) return;
15751
15752     out->unit = in->unit;
15753     out->scope = in->scope;
15754     out->storage = in->storage;
15755     memcpy(out->uuid, in->uuid, VK_UUID_SIZE * sizeof(uint8_t));
15756 }
15757 #endif /* USE_STRUCT_CONVERSION */
15758
15759 #if defined(USE_STRUCT_CONVERSION)
15760 static inline VkPerformanceCounterKHR *convert_VkPerformanceCounterKHR_array_win32_to_host(struct conversion_context *ctx, const VkPerformanceCounterKHR32 *in, uint32_t count)
15761 {
15762     VkPerformanceCounterKHR *out;
15763     unsigned int i;
15764
15765     if (!in || !count) return NULL;
15766
15767     out = conversion_context_alloc(ctx, count * sizeof(*out));
15768     for (i = 0; i < count; i++)
15769     {
15770         convert_VkPerformanceCounterKHR_win32_to_host(&in[i], &out[i]);
15771     }
15772
15773     return out;
15774 }
15775 #endif /* USE_STRUCT_CONVERSION */
15776
15777 #if defined(USE_STRUCT_CONVERSION)
15778 static inline void convert_VkPerformanceCounterKHR_array_host_to_win32(const VkPerformanceCounterKHR *in, VkPerformanceCounterKHR32 *out, uint32_t count)
15779 {
15780     unsigned int i;
15781
15782     if (!in) return;
15783
15784     for (i = 0; i < count; i++)
15785     {
15786         convert_VkPerformanceCounterKHR_host_to_win32(&in[i], &out[i]);
15787     }
15788 }
15789 #endif /* USE_STRUCT_CONVERSION */
15790
15791 #if defined(USE_STRUCT_CONVERSION)
15792 static inline void convert_VkPerformanceCounterDescriptionKHR_win32_to_host(const VkPerformanceCounterDescriptionKHR32 *in, VkPerformanceCounterDescriptionKHR *out)
15793 {
15794     if (!in) return;
15795
15796     out->sType = in->sType;
15797     out->pNext = in->pNext;
15798 }
15799 #endif /* USE_STRUCT_CONVERSION */
15800
15801 #if defined(USE_STRUCT_CONVERSION)
15802 static inline void convert_VkPerformanceCounterDescriptionKHR_host_to_win32(const VkPerformanceCounterDescriptionKHR *in, VkPerformanceCounterDescriptionKHR32 *out)
15803 {
15804     if (!in) return;
15805
15806     out->flags = in->flags;
15807     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
15808     memcpy(out->category, in->category, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
15809     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
15810 }
15811 #endif /* USE_STRUCT_CONVERSION */
15812
15813 #if defined(USE_STRUCT_CONVERSION)
15814 static inline VkPerformanceCounterDescriptionKHR *convert_VkPerformanceCounterDescriptionKHR_array_win32_to_host(struct conversion_context *ctx, const VkPerformanceCounterDescriptionKHR32 *in, uint32_t count)
15815 {
15816     VkPerformanceCounterDescriptionKHR *out;
15817     unsigned int i;
15818
15819     if (!in || !count) return NULL;
15820
15821     out = conversion_context_alloc(ctx, count * sizeof(*out));
15822     for (i = 0; i < count; i++)
15823     {
15824         convert_VkPerformanceCounterDescriptionKHR_win32_to_host(&in[i], &out[i]);
15825     }
15826
15827     return out;
15828 }
15829 #endif /* USE_STRUCT_CONVERSION */
15830
15831 #if defined(USE_STRUCT_CONVERSION)
15832 static inline void convert_VkPerformanceCounterDescriptionKHR_array_host_to_win32(const VkPerformanceCounterDescriptionKHR *in, VkPerformanceCounterDescriptionKHR32 *out, uint32_t count)
15833 {
15834     unsigned int i;
15835
15836     if (!in) return;
15837
15838     for (i = 0; i < count; i++)
15839     {
15840         convert_VkPerformanceCounterDescriptionKHR_host_to_win32(&in[i], &out[i]);
15841     }
15842 }
15843 #endif /* USE_STRUCT_CONVERSION */
15844
15845 #if defined(USE_STRUCT_CONVERSION)
15846 static inline void convert_VkMappedMemoryRange_win32_to_host(const VkMappedMemoryRange32 *in, VkMappedMemoryRange *out)
15847 {
15848     if (!in) return;
15849
15850     out->sType = in->sType;
15851     out->pNext = in->pNext;
15852     out->memory = in->memory;
15853     out->offset = in->offset;
15854     out->size = in->size;
15855 }
15856 #endif /* USE_STRUCT_CONVERSION */
15857
15858 #if defined(USE_STRUCT_CONVERSION)
15859 static inline const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win32_to_host(struct conversion_context *ctx, const VkMappedMemoryRange32 *in, uint32_t count)
15860 {
15861     VkMappedMemoryRange *out;
15862     unsigned int i;
15863
15864     if (!in || !count) return NULL;
15865
15866     out = conversion_context_alloc(ctx, count * sizeof(*out));
15867     for (i = 0; i < count; i++)
15868     {
15869         convert_VkMappedMemoryRange_win32_to_host(&in[i], &out[i]);
15870     }
15871
15872     return out;
15873 }
15874 #endif /* USE_STRUCT_CONVERSION */
15875
15876 #if defined(USE_STRUCT_CONVERSION)
15877 static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_host(const VkAccelerationStructureBuildSizesInfoKHR32 *in, VkAccelerationStructureBuildSizesInfoKHR *out)
15878 {
15879     if (!in) return;
15880
15881     out->sType = in->sType;
15882     out->pNext = in->pNext;
15883     out->accelerationStructureSize = in->accelerationStructureSize;
15884     out->updateScratchSize = in->updateScratchSize;
15885     out->buildScratchSize = in->buildScratchSize;
15886 }
15887 #endif /* USE_STRUCT_CONVERSION */
15888
15889 #if defined(USE_STRUCT_CONVERSION)
15890 static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win32(const VkAccelerationStructureBuildSizesInfoKHR *in, VkAccelerationStructureBuildSizesInfoKHR32 *out)
15891 {
15892     if (!in) return;
15893
15894     out->accelerationStructureSize = in->accelerationStructureSize;
15895     out->updateScratchSize = in->updateScratchSize;
15896     out->buildScratchSize = in->buildScratchSize;
15897 }
15898 #endif /* USE_STRUCT_CONVERSION */
15899
15900 #if defined(USE_STRUCT_CONVERSION)
15901 static inline void convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_host(const VkAccelerationStructureDeviceAddressInfoKHR32 *in, VkAccelerationStructureDeviceAddressInfoKHR *out)
15902 {
15903     if (!in) return;
15904
15905     out->sType = in->sType;
15906     out->pNext = in->pNext;
15907     out->accelerationStructure = in->accelerationStructure;
15908 }
15909 #endif /* USE_STRUCT_CONVERSION */
15910
15911 #if defined(USE_STRUCT_CONVERSION)
15912 static inline void convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32_to_host(const VkAccelerationStructureMemoryRequirementsInfoNV32 *in, VkAccelerationStructureMemoryRequirementsInfoNV *out)
15913 {
15914     if (!in) return;
15915
15916     out->sType = in->sType;
15917     out->pNext = in->pNext;
15918     out->type = in->type;
15919     out->accelerationStructure = in->accelerationStructure;
15920 }
15921 #endif /* USE_STRUCT_CONVERSION */
15922
15923 #if defined(USE_STRUCT_CONVERSION)
15924 static inline void convert_VkMemoryRequirements_host_to_win32(const VkMemoryRequirements *in, VkMemoryRequirements32 *out)
15925 {
15926     if (!in) return;
15927
15928     out->size = in->size;
15929     out->alignment = in->alignment;
15930     out->memoryTypeBits = in->memoryTypeBits;
15931 }
15932 #endif /* USE_STRUCT_CONVERSION */
15933
15934 #if defined(USE_STRUCT_CONVERSION)
15935 static inline void convert_VkMemoryRequirements2KHR_win32_to_host(const VkMemoryRequirements2KHR32 *in, VkMemoryRequirements2KHR *out)
15936 {
15937     if (!in) return;
15938
15939     out->sType = in->sType;
15940     out->pNext = in->pNext;
15941 }
15942 #endif /* USE_STRUCT_CONVERSION */
15943
15944 #if defined(USE_STRUCT_CONVERSION)
15945 static inline void convert_VkMemoryRequirements2KHR_host_to_win32(const VkMemoryRequirements2KHR *in, VkMemoryRequirements2KHR32 *out)
15946 {
15947     if (!in) return;
15948
15949     convert_VkMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
15950 }
15951 #endif /* USE_STRUCT_CONVERSION */
15952
15953 #if defined(USE_STRUCT_CONVERSION)
15954 static inline void convert_VkBufferDeviceAddressInfo_win32_to_host(const VkBufferDeviceAddressInfo32 *in, VkBufferDeviceAddressInfo *out)
15955 {
15956     if (!in) return;
15957
15958     out->sType = in->sType;
15959     out->pNext = in->pNext;
15960     out->buffer = in->buffer;
15961 }
15962 #endif /* USE_STRUCT_CONVERSION */
15963
15964 #if defined(USE_STRUCT_CONVERSION)
15965 static inline void convert_VkBufferMemoryRequirementsInfo2_win32_to_host(const VkBufferMemoryRequirementsInfo232 *in, VkBufferMemoryRequirementsInfo2 *out)
15966 {
15967     if (!in) return;
15968
15969     out->sType = in->sType;
15970     out->pNext = in->pNext;
15971     out->buffer = in->buffer;
15972 }
15973 #endif /* USE_STRUCT_CONVERSION */
15974
15975 #if defined(USE_STRUCT_CONVERSION)
15976 static inline void convert_VkMemoryRequirements2_win32_to_host(struct conversion_context *ctx, const VkMemoryRequirements232 *in, VkMemoryRequirements2 *out)
15977 {
15978     const VkBaseInStructure *in_header;
15979     VkBaseOutStructure *out_header = (void *)out;
15980
15981     if (!in) return;
15982
15983     out->sType = in->sType;
15984     out->pNext = NULL;
15985
15986     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
15987     {
15988         switch (in_header->sType)
15989         {
15990         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
15991         {
15992             VkMemoryDedicatedRequirements *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15993             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
15994             out_ext->pNext = NULL;
15995             out_header->pNext = (void *)out_ext;
15996             out_header = (void *)out_ext;
15997             break;
15998         }
15999         default:
16000             FIXME("Unhandled sType %u.", in_header->sType);
16001             break;
16002         }
16003     }
16004 }
16005 #endif /* USE_STRUCT_CONVERSION */
16006
16007 #if defined(USE_STRUCT_CONVERSION)
16008 static inline void convert_VkMemoryRequirements2_host_to_win32(const VkMemoryRequirements2 *in, VkMemoryRequirements232 *out)
16009 {
16010     const VkBaseInStructure *in_header;
16011     VkBaseOutStructure *out_header = (void *)out;
16012
16013     if (!in) return;
16014
16015     convert_VkMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
16016
16017     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
16018     {
16019         switch (in_header->sType)
16020         {
16021         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
16022         {
16023             VkMemoryDedicatedRequirements32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS);
16024             const VkMemoryDedicatedRequirements *in_ext = (const VkMemoryDedicatedRequirements *)in_header;
16025             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
16026             out_ext->prefersDedicatedAllocation = in_ext->prefersDedicatedAllocation;
16027             out_ext->requiresDedicatedAllocation = in_ext->requiresDedicatedAllocation;
16028             out_header = (void *)out_ext;
16029             break;
16030         }
16031         default:
16032             break;
16033         }
16034     }
16035 }
16036 #endif /* USE_STRUCT_CONVERSION */
16037
16038 #if defined(USE_STRUCT_CONVERSION)
16039 static inline void convert_VkCalibratedTimestampInfoEXT_win32_to_host(const VkCalibratedTimestampInfoEXT32 *in, VkCalibratedTimestampInfoEXT *out)
16040 {
16041     if (!in) return;
16042
16043     out->sType = in->sType;
16044     out->pNext = in->pNext;
16045     out->timeDomain = in->timeDomain;
16046 }
16047 #endif /* USE_STRUCT_CONVERSION */
16048
16049 #if defined(USE_STRUCT_CONVERSION)
16050 static inline const VkCalibratedTimestampInfoEXT *convert_VkCalibratedTimestampInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkCalibratedTimestampInfoEXT32 *in, uint32_t count)
16051 {
16052     VkCalibratedTimestampInfoEXT *out;
16053     unsigned int i;
16054
16055     if (!in || !count) return NULL;
16056
16057     out = conversion_context_alloc(ctx, count * sizeof(*out));
16058     for (i = 0; i < count; i++)
16059     {
16060         convert_VkCalibratedTimestampInfoEXT_win32_to_host(&in[i], &out[i]);
16061     }
16062
16063     return out;
16064 }
16065 #endif /* USE_STRUCT_CONVERSION */
16066
16067 #if defined(USE_STRUCT_CONVERSION)
16068 static inline void convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host(const VkDescriptorSetBindingReferenceVALVE32 *in, VkDescriptorSetBindingReferenceVALVE *out)
16069 {
16070     if (!in) return;
16071
16072     out->sType = in->sType;
16073     out->pNext = in->pNext;
16074     out->descriptorSetLayout = in->descriptorSetLayout;
16075     out->binding = in->binding;
16076 }
16077 #endif /* USE_STRUCT_CONVERSION */
16078
16079 #if defined(USE_STRUCT_CONVERSION)
16080 static inline void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_win32_to_host(const VkDescriptorSetLayoutHostMappingInfoVALVE32 *in, VkDescriptorSetLayoutHostMappingInfoVALVE *out)
16081 {
16082     if (!in) return;
16083
16084     out->sType = in->sType;
16085     out->pNext = in->pNext;
16086     out->descriptorOffset = in->descriptorOffset;
16087     out->descriptorSize = in->descriptorSize;
16088 }
16089 #endif /* USE_STRUCT_CONVERSION */
16090
16091 #if defined(USE_STRUCT_CONVERSION)
16092 static inline void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_host_to_win32(const VkDescriptorSetLayoutHostMappingInfoVALVE *in, VkDescriptorSetLayoutHostMappingInfoVALVE32 *out)
16093 {
16094     if (!in) return;
16095
16096     out->descriptorOffset = in->descriptorOffset;
16097     out->descriptorSize = in->descriptorSize;
16098 }
16099 #endif /* USE_STRUCT_CONVERSION */
16100
16101 #if defined(USE_STRUCT_CONVERSION)
16102 static inline void convert_VkDescriptorSetLayoutSupport_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutSupport32 *in, VkDescriptorSetLayoutSupport *out)
16103 {
16104     const VkBaseInStructure *in_header;
16105     VkBaseOutStructure *out_header = (void *)out;
16106
16107     if (!in) return;
16108
16109     out->sType = in->sType;
16110     out->pNext = NULL;
16111
16112     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
16113     {
16114         switch (in_header->sType)
16115         {
16116         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
16117         {
16118             VkDescriptorSetVariableDescriptorCountLayoutSupport *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16119             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
16120             out_ext->pNext = NULL;
16121             out_header->pNext = (void *)out_ext;
16122             out_header = (void *)out_ext;
16123             break;
16124         }
16125         default:
16126             FIXME("Unhandled sType %u.", in_header->sType);
16127             break;
16128         }
16129     }
16130 }
16131 #endif /* USE_STRUCT_CONVERSION */
16132
16133 #if defined(USE_STRUCT_CONVERSION)
16134 static inline void convert_VkDescriptorSetLayoutSupport_host_to_win32(const VkDescriptorSetLayoutSupport *in, VkDescriptorSetLayoutSupport32 *out)
16135 {
16136     const VkBaseInStructure *in_header;
16137     VkBaseOutStructure *out_header = (void *)out;
16138
16139     if (!in) return;
16140
16141     out->supported = in->supported;
16142
16143     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
16144     {
16145         switch (in_header->sType)
16146         {
16147         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
16148         {
16149             VkDescriptorSetVariableDescriptorCountLayoutSupport32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT);
16150             const VkDescriptorSetVariableDescriptorCountLayoutSupport *in_ext = (const VkDescriptorSetVariableDescriptorCountLayoutSupport *)in_header;
16151             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
16152             out_ext->maxVariableDescriptorCount = in_ext->maxVariableDescriptorCount;
16153             out_header = (void *)out_ext;
16154             break;
16155         }
16156         default:
16157             break;
16158         }
16159     }
16160 }
16161 #endif /* USE_STRUCT_CONVERSION */
16162
16163 #if defined(USE_STRUCT_CONVERSION)
16164 static inline void convert_VkAccelerationStructureVersionInfoKHR_win32_to_host(const VkAccelerationStructureVersionInfoKHR32 *in, VkAccelerationStructureVersionInfoKHR *out)
16165 {
16166     if (!in) return;
16167
16168     out->sType = in->sType;
16169     out->pNext = in->pNext;
16170     out->pVersionData = in->pVersionData;
16171 }
16172 #endif /* USE_STRUCT_CONVERSION */
16173
16174 #if defined(USE_STRUCT_CONVERSION)
16175 static inline const VkBufferCreateInfo *convert_VkBufferCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, uint32_t count)
16176 {
16177     VkBufferCreateInfo *out;
16178     unsigned int i;
16179
16180     if (!in || !count) return NULL;
16181
16182     out = conversion_context_alloc(ctx, count * sizeof(*out));
16183     for (i = 0; i < count; i++)
16184     {
16185         convert_VkBufferCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
16186     }
16187
16188     return out;
16189 }
16190 #endif /* USE_STRUCT_CONVERSION */
16191
16192 #if defined(USE_STRUCT_CONVERSION)
16193 static inline void convert_VkDeviceBufferMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceBufferMemoryRequirements32 *in, VkDeviceBufferMemoryRequirements *out)
16194 {
16195     if (!in) return;
16196
16197     out->sType = in->sType;
16198     out->pNext = in->pNext;
16199     out->pCreateInfo = convert_VkBufferCreateInfo_array_win32_to_host(ctx, in->pCreateInfo, 1);
16200 }
16201 #endif /* USE_STRUCT_CONVERSION */
16202
16203 #if defined(USE_STRUCT_CONVERSION)
16204 static inline void convert_VkDeviceFaultCountsEXT_win32_to_host(const VkDeviceFaultCountsEXT32 *in, VkDeviceFaultCountsEXT *out)
16205 {
16206     if (!in) return;
16207
16208     out->sType = in->sType;
16209     out->pNext = in->pNext;
16210     out->addressInfoCount = in->addressInfoCount;
16211     out->vendorInfoCount = in->vendorInfoCount;
16212     out->vendorBinarySize = in->vendorBinarySize;
16213 }
16214 #endif /* USE_STRUCT_CONVERSION */
16215
16216 #if defined(USE_STRUCT_CONVERSION)
16217 static inline void convert_VkDeviceFaultCountsEXT_host_to_win32(const VkDeviceFaultCountsEXT *in, VkDeviceFaultCountsEXT32 *out)
16218 {
16219     if (!in) return;
16220
16221     out->addressInfoCount = in->addressInfoCount;
16222     out->vendorInfoCount = in->vendorInfoCount;
16223     out->vendorBinarySize = in->vendorBinarySize;
16224 }
16225 #endif /* USE_STRUCT_CONVERSION */
16226
16227 #if defined(USE_STRUCT_CONVERSION)
16228 static inline void convert_VkDeviceFaultAddressInfoEXT_win32_to_host(const VkDeviceFaultAddressInfoEXT32 *in, VkDeviceFaultAddressInfoEXT *out)
16229 {
16230     if (!in) return;
16231
16232     out->addressType = in->addressType;
16233     out->reportedAddress = in->reportedAddress;
16234     out->addressPrecision = in->addressPrecision;
16235 }
16236 #endif /* USE_STRUCT_CONVERSION */
16237
16238 #if defined(USE_STRUCT_CONVERSION)
16239 static inline void convert_VkDeviceFaultAddressInfoEXT_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out)
16240 {
16241     if (!in) return;
16242
16243     out->addressType = in->addressType;
16244     out->reportedAddress = in->reportedAddress;
16245     out->addressPrecision = in->addressPrecision;
16246 }
16247 #endif /* USE_STRUCT_CONVERSION */
16248
16249 #if defined(USE_STRUCT_CONVERSION)
16250 static inline VkDeviceFaultAddressInfoEXT *convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultAddressInfoEXT32 *in, uint32_t count)
16251 {
16252     VkDeviceFaultAddressInfoEXT *out;
16253     unsigned int i;
16254
16255     if (!in || !count) return NULL;
16256
16257     out = conversion_context_alloc(ctx, count * sizeof(*out));
16258     for (i = 0; i < count; i++)
16259     {
16260         convert_VkDeviceFaultAddressInfoEXT_win32_to_host(&in[i], &out[i]);
16261     }
16262
16263     return out;
16264 }
16265 #endif /* USE_STRUCT_CONVERSION */
16266
16267 #if defined(USE_STRUCT_CONVERSION)
16268 static inline void convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out, uint32_t count)
16269 {
16270     unsigned int i;
16271
16272     if (!in) return;
16273
16274     for (i = 0; i < count; i++)
16275     {
16276         convert_VkDeviceFaultAddressInfoEXT_host_to_win32(&in[i], &out[i]);
16277     }
16278 }
16279 #endif /* USE_STRUCT_CONVERSION */
16280
16281 #if defined(USE_STRUCT_CONVERSION)
16282 static inline void convert_VkDeviceFaultVendorInfoEXT_win32_to_host(const VkDeviceFaultVendorInfoEXT32 *in, VkDeviceFaultVendorInfoEXT *out)
16283 {
16284     if (!in) return;
16285
16286     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
16287     out->vendorFaultCode = in->vendorFaultCode;
16288     out->vendorFaultData = in->vendorFaultData;
16289 }
16290 #endif /* USE_STRUCT_CONVERSION */
16291
16292 #if defined(USE_STRUCT_CONVERSION)
16293 static inline void convert_VkDeviceFaultVendorInfoEXT_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out)
16294 {
16295     if (!in) return;
16296
16297     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
16298     out->vendorFaultCode = in->vendorFaultCode;
16299     out->vendorFaultData = in->vendorFaultData;
16300 }
16301 #endif /* USE_STRUCT_CONVERSION */
16302
16303 #if defined(USE_STRUCT_CONVERSION)
16304 static inline VkDeviceFaultVendorInfoEXT *convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultVendorInfoEXT32 *in, uint32_t count)
16305 {
16306     VkDeviceFaultVendorInfoEXT *out;
16307     unsigned int i;
16308
16309     if (!in || !count) return NULL;
16310
16311     out = conversion_context_alloc(ctx, count * sizeof(*out));
16312     for (i = 0; i < count; i++)
16313     {
16314         convert_VkDeviceFaultVendorInfoEXT_win32_to_host(&in[i], &out[i]);
16315     }
16316
16317     return out;
16318 }
16319 #endif /* USE_STRUCT_CONVERSION */
16320
16321 #if defined(USE_STRUCT_CONVERSION)
16322 static inline void convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out, uint32_t count)
16323 {
16324     unsigned int i;
16325
16326     if (!in) return;
16327
16328     for (i = 0; i < count; i++)
16329     {
16330         convert_VkDeviceFaultVendorInfoEXT_host_to_win32(&in[i], &out[i]);
16331     }
16332 }
16333 #endif /* USE_STRUCT_CONVERSION */
16334
16335 #if defined(USE_STRUCT_CONVERSION)
16336 static inline void convert_VkDeviceFaultInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultInfoEXT32 *in, VkDeviceFaultInfoEXT *out)
16337 {
16338     if (!in) return;
16339
16340     out->sType = in->sType;
16341     out->pNext = in->pNext;
16342     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
16343     out->pAddressInfos = convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(ctx, in->pAddressInfos, 1);
16344     out->pVendorInfos = convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(ctx, in->pVendorInfos, 1);
16345     out->pVendorBinaryData = in->pVendorBinaryData;
16346 }
16347 #endif /* USE_STRUCT_CONVERSION */
16348
16349 #if defined(USE_STRUCT_CONVERSION)
16350 static inline void convert_VkDeviceFaultInfoEXT_host_to_win32(const VkDeviceFaultInfoEXT *in, VkDeviceFaultInfoEXT32 *out)
16351 {
16352     if (!in) return;
16353
16354     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
16355     convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(in->pAddressInfos, out->pAddressInfos, 1);
16356     convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(in->pVendorInfos, out->pVendorInfos, 1);
16357     out->pVendorBinaryData = in->pVendorBinaryData;
16358 }
16359 #endif /* USE_STRUCT_CONVERSION */
16360
16361 #if defined(USE_STRUCT_CONVERSION)
16362 static inline void convert_VkDeviceGroupPresentCapabilitiesKHR_win32_to_host(const VkDeviceGroupPresentCapabilitiesKHR32 *in, VkDeviceGroupPresentCapabilitiesKHR *out)
16363 {
16364     if (!in) return;
16365
16366     out->sType = in->sType;
16367     out->pNext = in->pNext;
16368 }
16369 #endif /* USE_STRUCT_CONVERSION */
16370
16371 #if defined(USE_STRUCT_CONVERSION)
16372 static inline void convert_VkDeviceGroupPresentCapabilitiesKHR_host_to_win32(const VkDeviceGroupPresentCapabilitiesKHR *in, VkDeviceGroupPresentCapabilitiesKHR32 *out)
16373 {
16374     if (!in) return;
16375
16376     memcpy(out->presentMask, in->presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
16377     out->modes = in->modes;
16378 }
16379 #endif /* USE_STRUCT_CONVERSION */
16380
16381 #if defined(USE_STRUCT_CONVERSION)
16382 static inline const VkImageCreateInfo *convert_VkImageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo32 *in, uint32_t count)
16383 {
16384     VkImageCreateInfo *out;
16385     unsigned int i;
16386
16387     if (!in || !count) return NULL;
16388
16389     out = conversion_context_alloc(ctx, count * sizeof(*out));
16390     for (i = 0; i < count; i++)
16391     {
16392         convert_VkImageCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
16393     }
16394
16395     return out;
16396 }
16397 #endif /* USE_STRUCT_CONVERSION */
16398
16399 #if defined(USE_STRUCT_CONVERSION)
16400 static inline void convert_VkDeviceImageMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceImageMemoryRequirements32 *in, VkDeviceImageMemoryRequirements *out)
16401 {
16402     if (!in) return;
16403
16404     out->sType = in->sType;
16405     out->pNext = in->pNext;
16406     out->pCreateInfo = convert_VkImageCreateInfo_array_win32_to_host(ctx, in->pCreateInfo, 1);
16407     out->planeAspect = in->planeAspect;
16408 }
16409 #endif /* USE_STRUCT_CONVERSION */
16410
16411 #if defined(USE_STRUCT_CONVERSION)
16412 static inline void convert_VkSparseImageMemoryRequirements_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out)
16413 {
16414     if (!in) return;
16415
16416     out->formatProperties = in->formatProperties;
16417     out->imageMipTailFirstLod = in->imageMipTailFirstLod;
16418     out->imageMipTailSize = in->imageMipTailSize;
16419     out->imageMipTailOffset = in->imageMipTailOffset;
16420     out->imageMipTailStride = in->imageMipTailStride;
16421 }
16422 #endif /* USE_STRUCT_CONVERSION */
16423
16424 #if defined(USE_STRUCT_CONVERSION)
16425 static inline void convert_VkSparseImageMemoryRequirements2_win32_to_host(const VkSparseImageMemoryRequirements232 *in, VkSparseImageMemoryRequirements2 *out)
16426 {
16427     if (!in) return;
16428
16429     out->sType = in->sType;
16430     out->pNext = in->pNext;
16431 }
16432 #endif /* USE_STRUCT_CONVERSION */
16433
16434 #if defined(USE_STRUCT_CONVERSION)
16435 static inline void convert_VkSparseImageMemoryRequirements2_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out)
16436 {
16437     if (!in) return;
16438
16439     convert_VkSparseImageMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
16440 }
16441 #endif /* USE_STRUCT_CONVERSION */
16442
16443 #if defined(USE_STRUCT_CONVERSION)
16444 static inline VkSparseImageMemoryRequirements2 *convert_VkSparseImageMemoryRequirements2_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryRequirements232 *in, uint32_t count)
16445 {
16446     VkSparseImageMemoryRequirements2 *out;
16447     unsigned int i;
16448
16449     if (!in || !count) return NULL;
16450
16451     out = conversion_context_alloc(ctx, count * sizeof(*out));
16452     for (i = 0; i < count; i++)
16453     {
16454         convert_VkSparseImageMemoryRequirements2_win32_to_host(&in[i], &out[i]);
16455     }
16456
16457     return out;
16458 }
16459 #endif /* USE_STRUCT_CONVERSION */
16460
16461 #if defined(USE_STRUCT_CONVERSION)
16462 static inline void convert_VkSparseImageMemoryRequirements2_array_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out, uint32_t count)
16463 {
16464     unsigned int i;
16465
16466     if (!in) return;
16467
16468     for (i = 0; i < count; i++)
16469     {
16470         convert_VkSparseImageMemoryRequirements2_host_to_win32(&in[i], &out[i]);
16471     }
16472 }
16473 #endif /* USE_STRUCT_CONVERSION */
16474
16475 #if defined(USE_STRUCT_CONVERSION)
16476 static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo32 *in, VkDeviceMemoryOpaqueCaptureAddressInfo *out)
16477 {
16478     if (!in) return;
16479
16480     out->sType = in->sType;
16481     out->pNext = in->pNext;
16482     out->memory = in->memory;
16483 }
16484 #endif /* USE_STRUCT_CONVERSION */
16485
16486 #if defined(USE_STRUCT_CONVERSION)
16487 static inline void convert_VkMicromapVersionInfoEXT_win32_to_host(const VkMicromapVersionInfoEXT32 *in, VkMicromapVersionInfoEXT *out)
16488 {
16489     if (!in) return;
16490
16491     out->sType = in->sType;
16492     out->pNext = in->pNext;
16493     out->pVersionData = in->pVersionData;
16494 }
16495 #endif /* USE_STRUCT_CONVERSION */
16496
16497 #if defined(USE_STRUCT_CONVERSION)
16498 static inline void convert_VkDeviceQueueInfo2_win32_to_host(const VkDeviceQueueInfo232 *in, VkDeviceQueueInfo2 *out)
16499 {
16500     if (!in) return;
16501
16502     out->sType = in->sType;
16503     out->pNext = in->pNext;
16504     out->flags = in->flags;
16505     out->queueFamilyIndex = in->queueFamilyIndex;
16506     out->queueIndex = in->queueIndex;
16507 }
16508 #endif /* USE_STRUCT_CONVERSION */
16509
16510 #if defined(USE_STRUCT_CONVERSION)
16511 static inline void convert_VkTilePropertiesQCOM_win32_to_host(const VkTilePropertiesQCOM32 *in, VkTilePropertiesQCOM *out)
16512 {
16513     if (!in) return;
16514
16515     out->sType = in->sType;
16516     out->pNext = in->pNext;
16517     out->tileSize = in->tileSize;
16518     out->apronSize = in->apronSize;
16519     out->origin = in->origin;
16520 }
16521 #endif /* USE_STRUCT_CONVERSION */
16522
16523 #if defined(USE_STRUCT_CONVERSION)
16524 static inline void convert_VkTilePropertiesQCOM_host_to_win32(const VkTilePropertiesQCOM *in, VkTilePropertiesQCOM32 *out)
16525 {
16526     if (!in) return;
16527
16528     out->tileSize = in->tileSize;
16529     out->apronSize = in->apronSize;
16530     out->origin = in->origin;
16531 }
16532 #endif /* USE_STRUCT_CONVERSION */
16533
16534 #if defined(USE_STRUCT_CONVERSION)
16535 static inline VkTilePropertiesQCOM *convert_VkTilePropertiesQCOM_array_win32_to_host(struct conversion_context *ctx, const VkTilePropertiesQCOM32 *in, uint32_t count)
16536 {
16537     VkTilePropertiesQCOM *out;
16538     unsigned int i;
16539
16540     if (!in || !count) return NULL;
16541
16542     out = conversion_context_alloc(ctx, count * sizeof(*out));
16543     for (i = 0; i < count; i++)
16544     {
16545         convert_VkTilePropertiesQCOM_win32_to_host(&in[i], &out[i]);
16546     }
16547
16548     return out;
16549 }
16550 #endif /* USE_STRUCT_CONVERSION */
16551
16552 #if defined(USE_STRUCT_CONVERSION)
16553 static inline void convert_VkTilePropertiesQCOM_array_host_to_win32(const VkTilePropertiesQCOM *in, VkTilePropertiesQCOM32 *out, uint32_t count)
16554 {
16555     unsigned int i;
16556
16557     if (!in) return;
16558
16559     for (i = 0; i < count; i++)
16560     {
16561         convert_VkTilePropertiesQCOM_host_to_win32(&in[i], &out[i]);
16562     }
16563 }
16564 #endif /* USE_STRUCT_CONVERSION */
16565
16566 #if defined(USE_STRUCT_CONVERSION)
16567 static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host(const VkGeneratedCommandsMemoryRequirementsInfoNV32 *in, VkGeneratedCommandsMemoryRequirementsInfoNV *out)
16568 {
16569     if (!in) return;
16570
16571     out->sType = in->sType;
16572     out->pNext = in->pNext;
16573     out->pipelineBindPoint = in->pipelineBindPoint;
16574     out->pipeline = in->pipeline;
16575     out->indirectCommandsLayout = in->indirectCommandsLayout;
16576     out->maxSequencesCount = in->maxSequencesCount;
16577 }
16578 #endif /* USE_STRUCT_CONVERSION */
16579
16580 #if defined(USE_STRUCT_CONVERSION)
16581 static inline void convert_VkImageMemoryRequirementsInfo2_win32_to_host(struct conversion_context *ctx, const VkImageMemoryRequirementsInfo232 *in, VkImageMemoryRequirementsInfo2 *out)
16582 {
16583     const VkBaseInStructure *in_header;
16584     VkBaseOutStructure *out_header = (void *)out;
16585
16586     if (!in) return;
16587
16588     out->sType = in->sType;
16589     out->pNext = NULL;
16590     out->image = in->image;
16591
16592     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
16593     {
16594         switch (in_header->sType)
16595         {
16596         case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
16597         {
16598             VkImagePlaneMemoryRequirementsInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16599             const VkImagePlaneMemoryRequirementsInfo32 *in_ext = (const VkImagePlaneMemoryRequirementsInfo32 *)in_header;
16600             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO;
16601             out_ext->pNext = NULL;
16602             out_ext->planeAspect = in_ext->planeAspect;
16603             out_header->pNext = (void *)out_ext;
16604             out_header = (void *)out_ext;
16605             break;
16606         }
16607         default:
16608             FIXME("Unhandled sType %u.", in_header->sType);
16609             break;
16610         }
16611     }
16612 }
16613 #endif /* USE_STRUCT_CONVERSION */
16614
16615 #if defined(USE_STRUCT_CONVERSION)
16616 static inline void convert_VkSparseImageMemoryRequirements_array_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out, uint32_t count)
16617 {
16618     unsigned int i;
16619
16620     if (!in) return;
16621
16622     for (i = 0; i < count; i++)
16623     {
16624         convert_VkSparseImageMemoryRequirements_host_to_win32(&in[i], &out[i]);
16625     }
16626 }
16627 #endif /* USE_STRUCT_CONVERSION */
16628
16629 #if defined(USE_STRUCT_CONVERSION)
16630 static inline void convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host(const VkImageSparseMemoryRequirementsInfo232 *in, VkImageSparseMemoryRequirementsInfo2 *out)
16631 {
16632     if (!in) return;
16633
16634     out->sType = in->sType;
16635     out->pNext = in->pNext;
16636     out->image = in->image;
16637 }
16638 #endif /* USE_STRUCT_CONVERSION */
16639
16640 #if defined(USE_STRUCT_CONVERSION)
16641 static inline void convert_VkSubresourceLayout_host_to_win32(const VkSubresourceLayout *in, VkSubresourceLayout32 *out)
16642 {
16643     if (!in) return;
16644
16645     out->offset = in->offset;
16646     out->size = in->size;
16647     out->rowPitch = in->rowPitch;
16648     out->arrayPitch = in->arrayPitch;
16649     out->depthPitch = in->depthPitch;
16650 }
16651 #endif /* USE_STRUCT_CONVERSION */
16652
16653 #if defined(USE_STRUCT_CONVERSION)
16654 static inline void convert_VkImageSubresource2EXT_win32_to_host(const VkImageSubresource2EXT32 *in, VkImageSubresource2EXT *out)
16655 {
16656     if (!in) return;
16657
16658     out->sType = in->sType;
16659     out->pNext = in->pNext;
16660     out->imageSubresource = in->imageSubresource;
16661 }
16662 #endif /* USE_STRUCT_CONVERSION */
16663
16664 #if defined(USE_STRUCT_CONVERSION)
16665 static inline void convert_VkSubresourceLayout2EXT_win32_to_host(struct conversion_context *ctx, const VkSubresourceLayout2EXT32 *in, VkSubresourceLayout2EXT *out)
16666 {
16667     const VkBaseInStructure *in_header;
16668     VkBaseOutStructure *out_header = (void *)out;
16669
16670     if (!in) return;
16671
16672     out->sType = in->sType;
16673     out->pNext = NULL;
16674
16675     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
16676     {
16677         switch (in_header->sType)
16678         {
16679         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
16680         {
16681             VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16682             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
16683             out_ext->pNext = NULL;
16684             out_header->pNext = (void *)out_ext;
16685             out_header = (void *)out_ext;
16686             break;
16687         }
16688         default:
16689             FIXME("Unhandled sType %u.", in_header->sType);
16690             break;
16691         }
16692     }
16693 }
16694 #endif /* USE_STRUCT_CONVERSION */
16695
16696 #if defined(USE_STRUCT_CONVERSION)
16697 static inline void convert_VkSubresourceLayout2EXT_host_to_win32(const VkSubresourceLayout2EXT *in, VkSubresourceLayout2EXT32 *out)
16698 {
16699     const VkBaseInStructure *in_header;
16700     VkBaseOutStructure *out_header = (void *)out;
16701
16702     if (!in) return;
16703
16704     convert_VkSubresourceLayout_host_to_win32(&in->subresourceLayout, &out->subresourceLayout);
16705
16706     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
16707     {
16708         switch (in_header->sType)
16709         {
16710         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
16711         {
16712             VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT);
16713             const VkImageCompressionPropertiesEXT *in_ext = (const VkImageCompressionPropertiesEXT *)in_header;
16714             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
16715             out_ext->imageCompressionFlags = in_ext->imageCompressionFlags;
16716             out_ext->imageCompressionFixedRateFlags = in_ext->imageCompressionFixedRateFlags;
16717             out_header = (void *)out_ext;
16718             break;
16719         }
16720         default:
16721             break;
16722         }
16723     }
16724 }
16725 #endif /* USE_STRUCT_CONVERSION */
16726
16727 #if defined(USE_STRUCT_CONVERSION)
16728 static inline void convert_VkImageViewAddressPropertiesNVX_win32_to_host(const VkImageViewAddressPropertiesNVX32 *in, VkImageViewAddressPropertiesNVX *out)
16729 {
16730     if (!in) return;
16731
16732     out->sType = in->sType;
16733     out->pNext = in->pNext;
16734 }
16735 #endif /* USE_STRUCT_CONVERSION */
16736
16737 #if defined(USE_STRUCT_CONVERSION)
16738 static inline void convert_VkImageViewAddressPropertiesNVX_host_to_win32(const VkImageViewAddressPropertiesNVX *in, VkImageViewAddressPropertiesNVX32 *out)
16739 {
16740     if (!in) return;
16741
16742     out->deviceAddress = in->deviceAddress;
16743     out->size = in->size;
16744 }
16745 #endif /* USE_STRUCT_CONVERSION */
16746
16747 #if defined(USE_STRUCT_CONVERSION)
16748 static inline void convert_VkImageViewHandleInfoNVX_win32_to_host(const VkImageViewHandleInfoNVX32 *in, VkImageViewHandleInfoNVX *out)
16749 {
16750     if (!in) return;
16751
16752     out->sType = in->sType;
16753     out->pNext = in->pNext;
16754     out->imageView = in->imageView;
16755     out->descriptorType = in->descriptorType;
16756     out->sampler = in->sampler;
16757 }
16758 #endif /* USE_STRUCT_CONVERSION */
16759
16760 #if defined(USE_STRUCT_CONVERSION)
16761 static inline void convert_VkMemoryHostPointerPropertiesEXT_win32_to_host(const VkMemoryHostPointerPropertiesEXT32 *in, VkMemoryHostPointerPropertiesEXT *out)
16762 {
16763     if (!in) return;
16764
16765     out->sType = in->sType;
16766     out->pNext = in->pNext;
16767 }
16768 #endif /* USE_STRUCT_CONVERSION */
16769
16770 #if defined(USE_STRUCT_CONVERSION)
16771 static inline void convert_VkMemoryHostPointerPropertiesEXT_host_to_win32(const VkMemoryHostPointerPropertiesEXT *in, VkMemoryHostPointerPropertiesEXT32 *out)
16772 {
16773     if (!in) return;
16774
16775     out->memoryTypeBits = in->memoryTypeBits;
16776 }
16777 #endif /* USE_STRUCT_CONVERSION */
16778
16779 #if defined(USE_STRUCT_CONVERSION)
16780 static inline void convert_VkMicromapBuildSizesInfoEXT_win32_to_host(const VkMicromapBuildSizesInfoEXT32 *in, VkMicromapBuildSizesInfoEXT *out)
16781 {
16782     if (!in) return;
16783
16784     out->sType = in->sType;
16785     out->pNext = in->pNext;
16786     out->micromapSize = in->micromapSize;
16787     out->buildScratchSize = in->buildScratchSize;
16788     out->discardable = in->discardable;
16789 }
16790 #endif /* USE_STRUCT_CONVERSION */
16791
16792 #if defined(USE_STRUCT_CONVERSION)
16793 static inline void convert_VkMicromapBuildSizesInfoEXT_host_to_win32(const VkMicromapBuildSizesInfoEXT *in, VkMicromapBuildSizesInfoEXT32 *out)
16794 {
16795     if (!in) return;
16796
16797     out->micromapSize = in->micromapSize;
16798     out->buildScratchSize = in->buildScratchSize;
16799     out->discardable = in->discardable;
16800 }
16801 #endif /* USE_STRUCT_CONVERSION */
16802
16803 #if defined(USE_STRUCT_CONVERSION)
16804 static inline void convert_VkPerformanceValueINTEL_win32_to_host(const VkPerformanceValueINTEL32 *in, VkPerformanceValueINTEL *out)
16805 {
16806     if (!in) return;
16807
16808     out->type = in->type;
16809     out->data = in->data;
16810 }
16811 #endif /* USE_STRUCT_CONVERSION */
16812
16813 #if defined(USE_STRUCT_CONVERSION)
16814 static inline void convert_VkPerformanceValueINTEL_host_to_win32(const VkPerformanceValueINTEL *in, VkPerformanceValueINTEL32 *out)
16815 {
16816     if (!in) return;
16817
16818     out->type = in->type;
16819     out->data = in->data;
16820 }
16821 #endif /* USE_STRUCT_CONVERSION */
16822
16823 #if defined(USE_STRUCT_CONVERSION)
16824 static inline void convert_VkCooperativeMatrixPropertiesNV_win32_to_host(const VkCooperativeMatrixPropertiesNV32 *in, VkCooperativeMatrixPropertiesNV *out)
16825 {
16826     if (!in) return;
16827
16828     out->sType = in->sType;
16829     out->pNext = in->pNext;
16830     out->MSize = in->MSize;
16831     out->NSize = in->NSize;
16832     out->KSize = in->KSize;
16833     out->AType = in->AType;
16834     out->BType = in->BType;
16835     out->CType = in->CType;
16836     out->DType = in->DType;
16837     out->scope = in->scope;
16838 }
16839 #endif /* USE_STRUCT_CONVERSION */
16840
16841 #if defined(USE_STRUCT_CONVERSION)
16842 static inline void convert_VkCooperativeMatrixPropertiesNV_host_to_win32(const VkCooperativeMatrixPropertiesNV *in, VkCooperativeMatrixPropertiesNV32 *out)
16843 {
16844     if (!in) return;
16845
16846     out->MSize = in->MSize;
16847     out->NSize = in->NSize;
16848     out->KSize = in->KSize;
16849     out->AType = in->AType;
16850     out->BType = in->BType;
16851     out->CType = in->CType;
16852     out->DType = in->DType;
16853     out->scope = in->scope;
16854 }
16855 #endif /* USE_STRUCT_CONVERSION */
16856
16857 #if defined(USE_STRUCT_CONVERSION)
16858 static inline VkCooperativeMatrixPropertiesNV *convert_VkCooperativeMatrixPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixPropertiesNV32 *in, uint32_t count)
16859 {
16860     VkCooperativeMatrixPropertiesNV *out;
16861     unsigned int i;
16862
16863     if (!in || !count) return NULL;
16864
16865     out = conversion_context_alloc(ctx, count * sizeof(*out));
16866     for (i = 0; i < count; i++)
16867     {
16868         convert_VkCooperativeMatrixPropertiesNV_win32_to_host(&in[i], &out[i]);
16869     }
16870
16871     return out;
16872 }
16873 #endif /* USE_STRUCT_CONVERSION */
16874
16875 #if defined(USE_STRUCT_CONVERSION)
16876 static inline void convert_VkCooperativeMatrixPropertiesNV_array_host_to_win32(const VkCooperativeMatrixPropertiesNV *in, VkCooperativeMatrixPropertiesNV32 *out, uint32_t count)
16877 {
16878     unsigned int i;
16879
16880     if (!in) return;
16881
16882     for (i = 0; i < count; i++)
16883     {
16884         convert_VkCooperativeMatrixPropertiesNV_host_to_win32(&in[i], &out[i]);
16885     }
16886 }
16887 #endif /* USE_STRUCT_CONVERSION */
16888
16889 #if defined(USE_STRUCT_CONVERSION)
16890 static inline void convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(const VkPhysicalDeviceExternalBufferInfo32 *in, VkPhysicalDeviceExternalBufferInfo *out)
16891 {
16892     if (!in) return;
16893
16894     out->sType = in->sType;
16895     out->pNext = in->pNext;
16896     out->flags = in->flags;
16897     out->usage = in->usage;
16898     out->handleType = in->handleType;
16899 }
16900 #endif /* USE_STRUCT_CONVERSION */
16901
16902 #if defined(USE_STRUCT_CONVERSION)
16903 static inline void convert_VkExternalBufferProperties_win32_to_host(const VkExternalBufferProperties32 *in, VkExternalBufferProperties *out)
16904 {
16905     if (!in) return;
16906
16907     out->sType = in->sType;
16908     out->pNext = in->pNext;
16909 }
16910 #endif /* USE_STRUCT_CONVERSION */
16911
16912 #if defined(USE_STRUCT_CONVERSION)
16913 static inline void convert_VkExternalBufferProperties_host_to_win32(const VkExternalBufferProperties *in, VkExternalBufferProperties32 *out)
16914 {
16915     if (!in) return;
16916
16917     out->externalMemoryProperties = in->externalMemoryProperties;
16918 }
16919 #endif /* USE_STRUCT_CONVERSION */
16920
16921 #if defined(USE_STRUCT_CONVERSION)
16922 static inline void convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host(const VkPhysicalDeviceExternalFenceInfo32 *in, VkPhysicalDeviceExternalFenceInfo *out)
16923 {
16924     if (!in) return;
16925
16926     out->sType = in->sType;
16927     out->pNext = in->pNext;
16928     out->handleType = in->handleType;
16929 }
16930 #endif /* USE_STRUCT_CONVERSION */
16931
16932 #if defined(USE_STRUCT_CONVERSION)
16933 static inline void convert_VkExternalFenceProperties_win32_to_host(const VkExternalFenceProperties32 *in, VkExternalFenceProperties *out)
16934 {
16935     if (!in) return;
16936
16937     out->sType = in->sType;
16938     out->pNext = in->pNext;
16939 }
16940 #endif /* USE_STRUCT_CONVERSION */
16941
16942 #if defined(USE_STRUCT_CONVERSION)
16943 static inline void convert_VkExternalFenceProperties_host_to_win32(const VkExternalFenceProperties *in, VkExternalFenceProperties32 *out)
16944 {
16945     if (!in) return;
16946
16947     out->exportFromImportedHandleTypes = in->exportFromImportedHandleTypes;
16948     out->compatibleHandleTypes = in->compatibleHandleTypes;
16949     out->externalFenceFeatures = in->externalFenceFeatures;
16950 }
16951 #endif /* USE_STRUCT_CONVERSION */
16952
16953 #if defined(USE_STRUCT_CONVERSION)
16954 static inline void convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalSemaphoreInfo32 *in, VkPhysicalDeviceExternalSemaphoreInfo *out)
16955 {
16956     const VkBaseInStructure *in_header;
16957     VkBaseOutStructure *out_header = (void *)out;
16958
16959     if (!in) return;
16960
16961     out->sType = in->sType;
16962     out->pNext = NULL;
16963     out->handleType = in->handleType;
16964
16965     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
16966     {
16967         switch (in_header->sType)
16968         {
16969         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
16970         {
16971             VkSemaphoreTypeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16972             const VkSemaphoreTypeCreateInfo32 *in_ext = (const VkSemaphoreTypeCreateInfo32 *)in_header;
16973             out_ext->sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
16974             out_ext->pNext = NULL;
16975             out_ext->semaphoreType = in_ext->semaphoreType;
16976             out_ext->initialValue = in_ext->initialValue;
16977             out_header->pNext = (void *)out_ext;
16978             out_header = (void *)out_ext;
16979             break;
16980         }
16981         default:
16982             FIXME("Unhandled sType %u.", in_header->sType);
16983             break;
16984         }
16985     }
16986 }
16987 #endif /* USE_STRUCT_CONVERSION */
16988
16989 #if defined(USE_STRUCT_CONVERSION)
16990 static inline void convert_VkExternalSemaphoreProperties_win32_to_host(const VkExternalSemaphoreProperties32 *in, VkExternalSemaphoreProperties *out)
16991 {
16992     if (!in) return;
16993
16994     out->sType = in->sType;
16995     out->pNext = in->pNext;
16996 }
16997 #endif /* USE_STRUCT_CONVERSION */
16998
16999 #if defined(USE_STRUCT_CONVERSION)
17000 static inline void convert_VkExternalSemaphoreProperties_host_to_win32(const VkExternalSemaphoreProperties *in, VkExternalSemaphoreProperties32 *out)
17001 {
17002     if (!in) return;
17003
17004     out->exportFromImportedHandleTypes = in->exportFromImportedHandleTypes;
17005     out->compatibleHandleTypes = in->compatibleHandleTypes;
17006     out->externalSemaphoreFeatures = in->externalSemaphoreFeatures;
17007 }
17008 #endif /* USE_STRUCT_CONVERSION */
17009
17010 #if defined(USE_STRUCT_CONVERSION)
17011 static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceFeatures232 *in, VkPhysicalDeviceFeatures2 *out)
17012 {
17013     const VkBaseInStructure *in_header;
17014     VkBaseOutStructure *out_header = (void *)out;
17015
17016     if (!in) return;
17017
17018     out->sType = in->sType;
17019     out->pNext = NULL;
17020     out->features = in->features;
17021
17022     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
17023     {
17024         switch (in_header->sType)
17025         {
17026         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
17027         {
17028             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17029             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *)in_header;
17030             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
17031             out_ext->pNext = NULL;
17032             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
17033             out_header->pNext = (void *)out_ext;
17034             out_header = (void *)out_ext;
17035             break;
17036         }
17037         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
17038         {
17039             VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17040             const VkPhysicalDevicePrivateDataFeatures32 *in_ext = (const VkPhysicalDevicePrivateDataFeatures32 *)in_header;
17041             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
17042             out_ext->pNext = NULL;
17043             out_ext->privateData = in_ext->privateData;
17044             out_header->pNext = (void *)out_ext;
17045             out_header = (void *)out_ext;
17046             break;
17047         }
17048         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
17049         {
17050             VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17051             const VkPhysicalDeviceVariablePointersFeatures32 *in_ext = (const VkPhysicalDeviceVariablePointersFeatures32 *)in_header;
17052             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
17053             out_ext->pNext = NULL;
17054             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
17055             out_ext->variablePointers = in_ext->variablePointers;
17056             out_header->pNext = (void *)out_ext;
17057             out_header = (void *)out_ext;
17058             break;
17059         }
17060         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
17061         {
17062             VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17063             const VkPhysicalDeviceMultiviewFeatures32 *in_ext = (const VkPhysicalDeviceMultiviewFeatures32 *)in_header;
17064             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
17065             out_ext->pNext = NULL;
17066             out_ext->multiview = in_ext->multiview;
17067             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
17068             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
17069             out_header->pNext = (void *)out_ext;
17070             out_header = (void *)out_ext;
17071             break;
17072         }
17073         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
17074         {
17075             VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17076             const VkPhysicalDevicePresentIdFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR32 *)in_header;
17077             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
17078             out_ext->pNext = NULL;
17079             out_ext->presentId = in_ext->presentId;
17080             out_header->pNext = (void *)out_ext;
17081             out_header = (void *)out_ext;
17082             break;
17083         }
17084         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
17085         {
17086             VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17087             const VkPhysicalDevicePresentWaitFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR32 *)in_header;
17088             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
17089             out_ext->pNext = NULL;
17090             out_ext->presentWait = in_ext->presentWait;
17091             out_header->pNext = (void *)out_ext;
17092             out_header = (void *)out_ext;
17093             break;
17094         }
17095         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
17096         {
17097             VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17098             const VkPhysicalDevice16BitStorageFeatures32 *in_ext = (const VkPhysicalDevice16BitStorageFeatures32 *)in_header;
17099             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
17100             out_ext->pNext = NULL;
17101             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
17102             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
17103             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
17104             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
17105             out_header->pNext = (void *)out_ext;
17106             out_header = (void *)out_ext;
17107             break;
17108         }
17109         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
17110         {
17111             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17112             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *)in_header;
17113             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
17114             out_ext->pNext = NULL;
17115             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
17116             out_header->pNext = (void *)out_ext;
17117             out_header = (void *)out_ext;
17118             break;
17119         }
17120         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
17121         {
17122             VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17123             const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *)in_header;
17124             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
17125             out_ext->pNext = NULL;
17126             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
17127             out_header->pNext = (void *)out_ext;
17128             out_header = (void *)out_ext;
17129             break;
17130         }
17131         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
17132         {
17133             VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17134             const VkPhysicalDeviceProtectedMemoryFeatures32 *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures32 *)in_header;
17135             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
17136             out_ext->pNext = NULL;
17137             out_ext->protectedMemory = in_ext->protectedMemory;
17138             out_header->pNext = (void *)out_ext;
17139             out_header = (void *)out_ext;
17140             break;
17141         }
17142         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
17143         {
17144             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17145             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *)in_header;
17146             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
17147             out_ext->pNext = NULL;
17148             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
17149             out_header->pNext = (void *)out_ext;
17150             out_header = (void *)out_ext;
17151             break;
17152         }
17153         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
17154         {
17155             VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17156             const VkPhysicalDeviceMultiDrawFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT32 *)in_header;
17157             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
17158             out_ext->pNext = NULL;
17159             out_ext->multiDraw = in_ext->multiDraw;
17160             out_header->pNext = (void *)out_ext;
17161             out_header = (void *)out_ext;
17162             break;
17163         }
17164         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
17165         {
17166             VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17167             const VkPhysicalDeviceInlineUniformBlockFeatures32 *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures32 *)in_header;
17168             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
17169             out_ext->pNext = NULL;
17170             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
17171             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
17172             out_header->pNext = (void *)out_ext;
17173             out_header = (void *)out_ext;
17174             break;
17175         }
17176         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
17177         {
17178             VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17179             const VkPhysicalDeviceMaintenance4Features32 *in_ext = (const VkPhysicalDeviceMaintenance4Features32 *)in_header;
17180             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
17181             out_ext->pNext = NULL;
17182             out_ext->maintenance4 = in_ext->maintenance4;
17183             out_header->pNext = (void *)out_ext;
17184             out_header = (void *)out_ext;
17185             break;
17186         }
17187         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
17188         {
17189             VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17190             const VkPhysicalDeviceShaderDrawParametersFeatures32 *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures32 *)in_header;
17191             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
17192             out_ext->pNext = NULL;
17193             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
17194             out_header->pNext = (void *)out_ext;
17195             out_header = (void *)out_ext;
17196             break;
17197         }
17198         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
17199         {
17200             VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17201             const VkPhysicalDeviceShaderFloat16Int8Features32 *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features32 *)in_header;
17202             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
17203             out_ext->pNext = NULL;
17204             out_ext->shaderFloat16 = in_ext->shaderFloat16;
17205             out_ext->shaderInt8 = in_ext->shaderInt8;
17206             out_header->pNext = (void *)out_ext;
17207             out_header = (void *)out_ext;
17208             break;
17209         }
17210         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
17211         {
17212             VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17213             const VkPhysicalDeviceHostQueryResetFeatures32 *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures32 *)in_header;
17214             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
17215             out_ext->pNext = NULL;
17216             out_ext->hostQueryReset = in_ext->hostQueryReset;
17217             out_header->pNext = (void *)out_ext;
17218             out_header = (void *)out_ext;
17219             break;
17220         }
17221         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
17222         {
17223             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17224             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *)in_header;
17225             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
17226             out_ext->pNext = NULL;
17227             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
17228             out_header->pNext = (void *)out_ext;
17229             out_header = (void *)out_ext;
17230             break;
17231         }
17232         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
17233         {
17234             VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17235             const VkPhysicalDeviceDescriptorIndexingFeatures32 *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures32 *)in_header;
17236             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
17237             out_ext->pNext = NULL;
17238             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
17239             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
17240             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
17241             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
17242             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
17243             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
17244             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
17245             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
17246             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
17247             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
17248             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
17249             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
17250             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
17251             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
17252             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
17253             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
17254             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
17255             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
17256             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
17257             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
17258             out_header->pNext = (void *)out_ext;
17259             out_header = (void *)out_ext;
17260             break;
17261         }
17262         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
17263         {
17264             VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17265             const VkPhysicalDeviceTimelineSemaphoreFeatures32 *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures32 *)in_header;
17266             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
17267             out_ext->pNext = NULL;
17268             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
17269             out_header->pNext = (void *)out_ext;
17270             out_header = (void *)out_ext;
17271             break;
17272         }
17273         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
17274         {
17275             VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17276             const VkPhysicalDevice8BitStorageFeatures32 *in_ext = (const VkPhysicalDevice8BitStorageFeatures32 *)in_header;
17277             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
17278             out_ext->pNext = NULL;
17279             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
17280             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
17281             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
17282             out_header->pNext = (void *)out_ext;
17283             out_header = (void *)out_ext;
17284             break;
17285         }
17286         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
17287         {
17288             VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17289             const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *)in_header;
17290             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
17291             out_ext->pNext = NULL;
17292             out_ext->conditionalRendering = in_ext->conditionalRendering;
17293             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
17294             out_header->pNext = (void *)out_ext;
17295             out_header = (void *)out_ext;
17296             break;
17297         }
17298         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
17299         {
17300             VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17301             const VkPhysicalDeviceVulkanMemoryModelFeatures32 *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures32 *)in_header;
17302             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
17303             out_ext->pNext = NULL;
17304             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
17305             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
17306             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
17307             out_header->pNext = (void *)out_ext;
17308             out_header = (void *)out_ext;
17309             break;
17310         }
17311         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
17312         {
17313             VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17314             const VkPhysicalDeviceShaderAtomicInt64Features32 *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features32 *)in_header;
17315             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
17316             out_ext->pNext = NULL;
17317             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
17318             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
17319             out_header->pNext = (void *)out_ext;
17320             out_header = (void *)out_ext;
17321             break;
17322         }
17323         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
17324         {
17325             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17326             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *)in_header;
17327             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
17328             out_ext->pNext = NULL;
17329             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
17330             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
17331             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
17332             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
17333             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
17334             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
17335             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
17336             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
17337             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
17338             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
17339             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
17340             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
17341             out_header->pNext = (void *)out_ext;
17342             out_header = (void *)out_ext;
17343             break;
17344         }
17345         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
17346         {
17347             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17348             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *)in_header;
17349             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
17350             out_ext->pNext = NULL;
17351             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
17352             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
17353             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
17354             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
17355             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
17356             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
17357             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
17358             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
17359             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
17360             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
17361             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
17362             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
17363             out_header->pNext = (void *)out_ext;
17364             out_header = (void *)out_ext;
17365             break;
17366         }
17367         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
17368         {
17369             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17370             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *)in_header;
17371             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
17372             out_ext->pNext = NULL;
17373             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
17374             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
17375             out_header->pNext = (void *)out_ext;
17376             out_header = (void *)out_ext;
17377             break;
17378         }
17379         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
17380         {
17381             VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17382             const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *)in_header;
17383             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
17384             out_ext->pNext = NULL;
17385             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
17386             out_header->pNext = (void *)out_ext;
17387             out_header = (void *)out_ext;
17388             break;
17389         }
17390         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
17391         {
17392             VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17393             const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *)in_header;
17394             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
17395             out_ext->pNext = NULL;
17396             out_ext->transformFeedback = in_ext->transformFeedback;
17397             out_ext->geometryStreams = in_ext->geometryStreams;
17398             out_header->pNext = (void *)out_ext;
17399             out_header = (void *)out_ext;
17400             break;
17401         }
17402         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
17403         {
17404             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17405             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *)in_header;
17406             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
17407             out_ext->pNext = NULL;
17408             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
17409             out_header->pNext = (void *)out_ext;
17410             out_header = (void *)out_ext;
17411             break;
17412         }
17413         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
17414         {
17415             VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17416             const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *)in_header;
17417             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
17418             out_ext->pNext = NULL;
17419             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
17420             out_header->pNext = (void *)out_ext;
17421             out_header = (void *)out_ext;
17422             break;
17423         }
17424         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
17425         {
17426             VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17427             const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *)in_header;
17428             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
17429             out_ext->pNext = NULL;
17430             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
17431             out_header->pNext = (void *)out_ext;
17432             out_header = (void *)out_ext;
17433             break;
17434         }
17435         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
17436         {
17437             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17438             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *)in_header;
17439             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
17440             out_ext->pNext = NULL;
17441             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
17442             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
17443             out_header->pNext = (void *)out_ext;
17444             out_header = (void *)out_ext;
17445             break;
17446         }
17447         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
17448         {
17449             VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17450             const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *)in_header;
17451             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
17452             out_ext->pNext = NULL;
17453             out_ext->imageFootprint = in_ext->imageFootprint;
17454             out_header->pNext = (void *)out_ext;
17455             out_header = (void *)out_ext;
17456             break;
17457         }
17458         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
17459         {
17460             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17461             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *)in_header;
17462             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
17463             out_ext->pNext = NULL;
17464             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
17465             out_header->pNext = (void *)out_ext;
17466             out_header = (void *)out_ext;
17467             break;
17468         }
17469         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
17470         {
17471             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17472             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *)in_header;
17473             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
17474             out_ext->pNext = NULL;
17475             out_ext->indirectCopy = in_ext->indirectCopy;
17476             out_header->pNext = (void *)out_ext;
17477             out_header = (void *)out_ext;
17478             break;
17479         }
17480         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
17481         {
17482             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17483             const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *)in_header;
17484             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
17485             out_ext->pNext = NULL;
17486             out_ext->memoryDecompression = in_ext->memoryDecompression;
17487             out_header->pNext = (void *)out_ext;
17488             out_header = (void *)out_ext;
17489             break;
17490         }
17491         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
17492         {
17493             VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17494             const VkPhysicalDeviceShadingRateImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV32 *)in_header;
17495             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
17496             out_ext->pNext = NULL;
17497             out_ext->shadingRateImage = in_ext->shadingRateImage;
17498             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
17499             out_header->pNext = (void *)out_ext;
17500             out_header = (void *)out_ext;
17501             break;
17502         }
17503         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
17504         {
17505             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17506             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *)in_header;
17507             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
17508             out_ext->pNext = NULL;
17509             out_ext->invocationMask = in_ext->invocationMask;
17510             out_header->pNext = (void *)out_ext;
17511             out_header = (void *)out_ext;
17512             break;
17513         }
17514         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
17515         {
17516             VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17517             const VkPhysicalDeviceMeshShaderFeaturesNV32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV32 *)in_header;
17518             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
17519             out_ext->pNext = NULL;
17520             out_ext->taskShader = in_ext->taskShader;
17521             out_ext->meshShader = in_ext->meshShader;
17522             out_header->pNext = (void *)out_ext;
17523             out_header = (void *)out_ext;
17524             break;
17525         }
17526         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
17527         {
17528             VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17529             const VkPhysicalDeviceMeshShaderFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT32 *)in_header;
17530             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
17531             out_ext->pNext = NULL;
17532             out_ext->taskShader = in_ext->taskShader;
17533             out_ext->meshShader = in_ext->meshShader;
17534             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
17535             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
17536             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
17537             out_header->pNext = (void *)out_ext;
17538             out_header = (void *)out_ext;
17539             break;
17540         }
17541         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
17542         {
17543             VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17544             const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *)in_header;
17545             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
17546             out_ext->pNext = NULL;
17547             out_ext->accelerationStructure = in_ext->accelerationStructure;
17548             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
17549             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
17550             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
17551             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
17552             out_header->pNext = (void *)out_ext;
17553             out_header = (void *)out_ext;
17554             break;
17555         }
17556         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
17557         {
17558             VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17559             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *)in_header;
17560             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
17561             out_ext->pNext = NULL;
17562             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
17563             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
17564             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
17565             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
17566             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
17567             out_header->pNext = (void *)out_ext;
17568             out_header = (void *)out_ext;
17569             break;
17570         }
17571         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
17572         {
17573             VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17574             const VkPhysicalDeviceRayQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR32 *)in_header;
17575             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
17576             out_ext->pNext = NULL;
17577             out_ext->rayQuery = in_ext->rayQuery;
17578             out_header->pNext = (void *)out_ext;
17579             out_header = (void *)out_ext;
17580             break;
17581         }
17582         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
17583         {
17584             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17585             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *)in_header;
17586             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
17587             out_ext->pNext = NULL;
17588             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
17589             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
17590             out_header->pNext = (void *)out_ext;
17591             out_header = (void *)out_ext;
17592             break;
17593         }
17594         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
17595         {
17596             VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17597             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *)in_header;
17598             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
17599             out_ext->pNext = NULL;
17600             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
17601             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
17602             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
17603             out_header->pNext = (void *)out_ext;
17604             out_header = (void *)out_ext;
17605             break;
17606         }
17607         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
17608         {
17609             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17610             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *)in_header;
17611             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
17612             out_ext->pNext = NULL;
17613             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
17614             out_header->pNext = (void *)out_ext;
17615             out_header = (void *)out_ext;
17616             break;
17617         }
17618         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
17619         {
17620             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17621             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *)in_header;
17622             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
17623             out_ext->pNext = NULL;
17624             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
17625             out_header->pNext = (void *)out_ext;
17626             out_header = (void *)out_ext;
17627             break;
17628         }
17629         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
17630         {
17631             VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17632             const VkPhysicalDeviceScalarBlockLayoutFeatures32 *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures32 *)in_header;
17633             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
17634             out_ext->pNext = NULL;
17635             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
17636             out_header->pNext = (void *)out_ext;
17637             out_header = (void *)out_ext;
17638             break;
17639         }
17640         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
17641         {
17642             VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17643             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *)in_header;
17644             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
17645             out_ext->pNext = NULL;
17646             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
17647             out_header->pNext = (void *)out_ext;
17648             out_header = (void *)out_ext;
17649             break;
17650         }
17651         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
17652         {
17653             VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17654             const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *)in_header;
17655             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
17656             out_ext->pNext = NULL;
17657             out_ext->depthClipEnable = in_ext->depthClipEnable;
17658             out_header->pNext = (void *)out_ext;
17659             out_header = (void *)out_ext;
17660             break;
17661         }
17662         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
17663         {
17664             VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17665             const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *)in_header;
17666             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
17667             out_ext->pNext = NULL;
17668             out_ext->memoryPriority = in_ext->memoryPriority;
17669             out_header->pNext = (void *)out_ext;
17670             out_header = (void *)out_ext;
17671             break;
17672         }
17673         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
17674         {
17675             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17676             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *)in_header;
17677             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
17678             out_ext->pNext = NULL;
17679             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
17680             out_header->pNext = (void *)out_ext;
17681             out_header = (void *)out_ext;
17682             break;
17683         }
17684         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
17685         {
17686             VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17687             const VkPhysicalDeviceBufferDeviceAddressFeatures32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures32 *)in_header;
17688             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
17689             out_ext->pNext = NULL;
17690             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
17691             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
17692             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
17693             out_header->pNext = (void *)out_ext;
17694             out_header = (void *)out_ext;
17695             break;
17696         }
17697         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
17698         {
17699             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17700             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *)in_header;
17701             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
17702             out_ext->pNext = NULL;
17703             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
17704             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
17705             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
17706             out_header->pNext = (void *)out_ext;
17707             out_header = (void *)out_ext;
17708             break;
17709         }
17710         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
17711         {
17712             VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17713             const VkPhysicalDeviceImagelessFramebufferFeatures32 *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures32 *)in_header;
17714             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
17715             out_ext->pNext = NULL;
17716             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
17717             out_header->pNext = (void *)out_ext;
17718             out_header = (void *)out_ext;
17719             break;
17720         }
17721         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
17722         {
17723             VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17724             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *)in_header;
17725             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
17726             out_ext->pNext = NULL;
17727             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
17728             out_header->pNext = (void *)out_ext;
17729             out_header = (void *)out_ext;
17730             break;
17731         }
17732         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
17733         {
17734             VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17735             const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *)in_header;
17736             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
17737             out_ext->pNext = NULL;
17738             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
17739             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
17740             out_header->pNext = (void *)out_ext;
17741             out_header = (void *)out_ext;
17742             break;
17743         }
17744         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
17745         {
17746             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17747             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *)in_header;
17748             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
17749             out_ext->pNext = NULL;
17750             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
17751             out_header->pNext = (void *)out_ext;
17752             out_header = (void *)out_ext;
17753             break;
17754         }
17755         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
17756         {
17757             VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17758             const VkPhysicalDevicePresentBarrierFeaturesNV32 *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV32 *)in_header;
17759             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
17760             out_ext->pNext = NULL;
17761             out_ext->presentBarrier = in_ext->presentBarrier;
17762             out_header->pNext = (void *)out_ext;
17763             out_header = (void *)out_ext;
17764             break;
17765         }
17766         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
17767         {
17768             VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17769             const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *)in_header;
17770             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
17771             out_ext->pNext = NULL;
17772             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
17773             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
17774             out_header->pNext = (void *)out_ext;
17775             out_header = (void *)out_ext;
17776             break;
17777         }
17778         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
17779         {
17780             VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17781             const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *)in_header;
17782             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
17783             out_ext->pNext = NULL;
17784             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
17785             out_header->pNext = (void *)out_ext;
17786             out_header = (void *)out_ext;
17787             break;
17788         }
17789         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
17790         {
17791             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17792             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *)in_header;
17793             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
17794             out_ext->pNext = NULL;
17795             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
17796             out_header->pNext = (void *)out_ext;
17797             out_header = (void *)out_ext;
17798             break;
17799         }
17800         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
17801         {
17802             VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17803             const VkPhysicalDeviceShaderClockFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR32 *)in_header;
17804             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
17805             out_ext->pNext = NULL;
17806             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
17807             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
17808             out_header->pNext = (void *)out_ext;
17809             out_header = (void *)out_ext;
17810             break;
17811         }
17812         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
17813         {
17814             VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17815             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *)in_header;
17816             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
17817             out_ext->pNext = NULL;
17818             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
17819             out_header->pNext = (void *)out_ext;
17820             out_header = (void *)out_ext;
17821             break;
17822         }
17823         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
17824         {
17825             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17826             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *)in_header;
17827             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
17828             out_ext->pNext = NULL;
17829             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
17830             out_header->pNext = (void *)out_ext;
17831             out_header = (void *)out_ext;
17832             break;
17833         }
17834         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
17835         {
17836             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17837             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *)in_header;
17838             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
17839             out_ext->pNext = NULL;
17840             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
17841             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
17842             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
17843             out_header->pNext = (void *)out_ext;
17844             out_header = (void *)out_ext;
17845             break;
17846         }
17847         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
17848         {
17849             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17850             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *)in_header;
17851             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
17852             out_ext->pNext = NULL;
17853             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
17854             out_header->pNext = (void *)out_ext;
17855             out_header = (void *)out_ext;
17856             break;
17857         }
17858         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
17859         {
17860             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17861             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *)in_header;
17862             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
17863             out_ext->pNext = NULL;
17864             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
17865             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
17866             out_header->pNext = (void *)out_ext;
17867             out_header = (void *)out_ext;
17868             break;
17869         }
17870         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
17871         {
17872             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17873             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *)in_header;
17874             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
17875             out_ext->pNext = NULL;
17876             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
17877             out_header->pNext = (void *)out_ext;
17878             out_header = (void *)out_ext;
17879             break;
17880         }
17881         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
17882         {
17883             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17884             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *)in_header;
17885             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
17886             out_ext->pNext = NULL;
17887             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
17888             out_header->pNext = (void *)out_ext;
17889             out_header = (void *)out_ext;
17890             break;
17891         }
17892         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
17893         {
17894             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17895             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *)in_header;
17896             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
17897             out_ext->pNext = NULL;
17898             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
17899             out_header->pNext = (void *)out_ext;
17900             out_header = (void *)out_ext;
17901             break;
17902         }
17903         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
17904         {
17905             VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17906             const VkPhysicalDeviceSubgroupSizeControlFeatures32 *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures32 *)in_header;
17907             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
17908             out_ext->pNext = NULL;
17909             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
17910             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
17911             out_header->pNext = (void *)out_ext;
17912             out_header = (void *)out_ext;
17913             break;
17914         }
17915         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
17916         {
17917             VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17918             const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *)in_header;
17919             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
17920             out_ext->pNext = NULL;
17921             out_ext->rectangularLines = in_ext->rectangularLines;
17922             out_ext->bresenhamLines = in_ext->bresenhamLines;
17923             out_ext->smoothLines = in_ext->smoothLines;
17924             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
17925             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
17926             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
17927             out_header->pNext = (void *)out_ext;
17928             out_header = (void *)out_ext;
17929             break;
17930         }
17931         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
17932         {
17933             VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17934             const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *)in_header;
17935             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
17936             out_ext->pNext = NULL;
17937             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
17938             out_header->pNext = (void *)out_ext;
17939             out_header = (void *)out_ext;
17940             break;
17941         }
17942         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
17943         {
17944             VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17945             const VkPhysicalDeviceVulkan11Features32 *in_ext = (const VkPhysicalDeviceVulkan11Features32 *)in_header;
17946             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
17947             out_ext->pNext = NULL;
17948             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
17949             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
17950             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
17951             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
17952             out_ext->multiview = in_ext->multiview;
17953             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
17954             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
17955             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
17956             out_ext->variablePointers = in_ext->variablePointers;
17957             out_ext->protectedMemory = in_ext->protectedMemory;
17958             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
17959             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
17960             out_header->pNext = (void *)out_ext;
17961             out_header = (void *)out_ext;
17962             break;
17963         }
17964         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
17965         {
17966             VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17967             const VkPhysicalDeviceVulkan12Features32 *in_ext = (const VkPhysicalDeviceVulkan12Features32 *)in_header;
17968             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
17969             out_ext->pNext = NULL;
17970             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
17971             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
17972             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
17973             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
17974             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
17975             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
17976             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
17977             out_ext->shaderFloat16 = in_ext->shaderFloat16;
17978             out_ext->shaderInt8 = in_ext->shaderInt8;
17979             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
17980             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
17981             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
17982             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
17983             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
17984             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
17985             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
17986             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
17987             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
17988             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
17989             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
17990             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
17991             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
17992             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
17993             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
17994             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
17995             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
17996             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
17997             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
17998             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
17999             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
18000             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
18001             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
18002             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
18003             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
18004             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
18005             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
18006             out_ext->hostQueryReset = in_ext->hostQueryReset;
18007             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
18008             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
18009             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
18010             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
18011             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
18012             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
18013             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
18014             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
18015             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
18016             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
18017             out_header->pNext = (void *)out_ext;
18018             out_header = (void *)out_ext;
18019             break;
18020         }
18021         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
18022         {
18023             VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18024             const VkPhysicalDeviceVulkan13Features32 *in_ext = (const VkPhysicalDeviceVulkan13Features32 *)in_header;
18025             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
18026             out_ext->pNext = NULL;
18027             out_ext->robustImageAccess = in_ext->robustImageAccess;
18028             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
18029             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
18030             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
18031             out_ext->privateData = in_ext->privateData;
18032             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
18033             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
18034             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
18035             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
18036             out_ext->synchronization2 = in_ext->synchronization2;
18037             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
18038             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
18039             out_ext->dynamicRendering = in_ext->dynamicRendering;
18040             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
18041             out_ext->maintenance4 = in_ext->maintenance4;
18042             out_header->pNext = (void *)out_ext;
18043             out_header = (void *)out_ext;
18044             break;
18045         }
18046         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
18047         {
18048             VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18049             const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *)in_header;
18050             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
18051             out_ext->pNext = NULL;
18052             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
18053             out_header->pNext = (void *)out_ext;
18054             out_header = (void *)out_ext;
18055             break;
18056         }
18057         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
18058         {
18059             VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18060             const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *)in_header;
18061             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
18062             out_ext->pNext = NULL;
18063             out_ext->customBorderColors = in_ext->customBorderColors;
18064             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
18065             out_header->pNext = (void *)out_ext;
18066             out_header = (void *)out_ext;
18067             break;
18068         }
18069         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
18070         {
18071             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18072             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *)in_header;
18073             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
18074             out_ext->pNext = NULL;
18075             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
18076             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
18077             out_header->pNext = (void *)out_ext;
18078             out_header = (void *)out_ext;
18079             break;
18080         }
18081         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
18082         {
18083             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18084             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *)in_header;
18085             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
18086             out_ext->pNext = NULL;
18087             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
18088             out_header->pNext = (void *)out_ext;
18089             out_header = (void *)out_ext;
18090             break;
18091         }
18092         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
18093         {
18094             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18095             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *)in_header;
18096             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
18097             out_ext->pNext = NULL;
18098             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
18099             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
18100             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
18101             out_header->pNext = (void *)out_ext;
18102             out_header = (void *)out_ext;
18103             break;
18104         }
18105         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
18106         {
18107             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18108             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *)in_header;
18109             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
18110             out_ext->pNext = NULL;
18111             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
18112             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
18113             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
18114             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
18115             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
18116             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
18117             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
18118             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
18119             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
18120             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
18121             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
18122             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
18123             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
18124             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
18125             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
18126             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
18127             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
18128             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
18129             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
18130             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
18131             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
18132             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
18133             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
18134             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
18135             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
18136             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
18137             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
18138             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
18139             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
18140             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
18141             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
18142             out_header->pNext = (void *)out_ext;
18143             out_header = (void *)out_ext;
18144             break;
18145         }
18146         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
18147         {
18148             VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18149             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *)in_header;
18150             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
18151             out_ext->pNext = NULL;
18152             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
18153             out_header->pNext = (void *)out_ext;
18154             out_header = (void *)out_ext;
18155             break;
18156         }
18157         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
18158         {
18159             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18160             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *)in_header;
18161             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
18162             out_ext->pNext = NULL;
18163             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
18164             out_header->pNext = (void *)out_ext;
18165             out_header = (void *)out_ext;
18166             break;
18167         }
18168         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
18169         {
18170             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18171             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *)in_header;
18172             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
18173             out_ext->pNext = NULL;
18174             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
18175             out_header->pNext = (void *)out_ext;
18176             out_header = (void *)out_ext;
18177             break;
18178         }
18179         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
18180         {
18181             VkPhysicalDeviceRobustness2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18182             const VkPhysicalDeviceRobustness2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT32 *)in_header;
18183             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
18184             out_ext->pNext = NULL;
18185             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
18186             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
18187             out_ext->nullDescriptor = in_ext->nullDescriptor;
18188             out_header->pNext = (void *)out_ext;
18189             out_header = (void *)out_ext;
18190             break;
18191         }
18192         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
18193         {
18194             VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18195             const VkPhysicalDeviceImageRobustnessFeatures32 *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures32 *)in_header;
18196             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
18197             out_ext->pNext = NULL;
18198             out_ext->robustImageAccess = in_ext->robustImageAccess;
18199             out_header->pNext = (void *)out_ext;
18200             out_header = (void *)out_ext;
18201             break;
18202         }
18203         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
18204         {
18205             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18206             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *)in_header;
18207             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
18208             out_ext->pNext = NULL;
18209             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
18210             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
18211             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
18212             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
18213             out_header->pNext = (void *)out_ext;
18214             out_header = (void *)out_ext;
18215             break;
18216         }
18217         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
18218         {
18219             VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18220             const VkPhysicalDevice4444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT32 *)in_header;
18221             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
18222             out_ext->pNext = NULL;
18223             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
18224             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
18225             out_header->pNext = (void *)out_ext;
18226             out_header = (void *)out_ext;
18227             break;
18228         }
18229         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
18230         {
18231             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18232             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *)in_header;
18233             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
18234             out_ext->pNext = NULL;
18235             out_ext->subpassShading = in_ext->subpassShading;
18236             out_header->pNext = (void *)out_ext;
18237             out_header = (void *)out_ext;
18238             break;
18239         }
18240         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
18241         {
18242             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18243             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *)in_header;
18244             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
18245             out_ext->pNext = NULL;
18246             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
18247             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
18248             out_header->pNext = (void *)out_ext;
18249             out_header = (void *)out_ext;
18250             break;
18251         }
18252         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
18253         {
18254             VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18255             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *)in_header;
18256             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
18257             out_ext->pNext = NULL;
18258             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
18259             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
18260             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
18261             out_header->pNext = (void *)out_ext;
18262             out_header = (void *)out_ext;
18263             break;
18264         }
18265         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
18266         {
18267             VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18268             const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *)in_header;
18269             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
18270             out_ext->pNext = NULL;
18271             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
18272             out_header->pNext = (void *)out_ext;
18273             out_header = (void *)out_ext;
18274             break;
18275         }
18276         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
18277         {
18278             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18279             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *)in_header;
18280             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
18281             out_ext->pNext = NULL;
18282             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
18283             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
18284             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
18285             out_header->pNext = (void *)out_ext;
18286             out_header = (void *)out_ext;
18287             break;
18288         }
18289         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
18290         {
18291             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18292             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *)in_header;
18293             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
18294             out_ext->pNext = NULL;
18295             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
18296             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
18297             out_header->pNext = (void *)out_ext;
18298             out_header = (void *)out_ext;
18299             break;
18300         }
18301         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
18302         {
18303             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18304             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *)in_header;
18305             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
18306             out_ext->pNext = NULL;
18307             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
18308             out_header->pNext = (void *)out_ext;
18309             out_header = (void *)out_ext;
18310             break;
18311         }
18312         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
18313         {
18314             VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18315             const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *)in_header;
18316             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
18317             out_ext->pNext = NULL;
18318             out_ext->depthClipControl = in_ext->depthClipControl;
18319             out_header->pNext = (void *)out_ext;
18320             out_header = (void *)out_ext;
18321             break;
18322         }
18323         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
18324         {
18325             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18326             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *)in_header;
18327             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
18328             out_ext->pNext = NULL;
18329             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
18330             out_header->pNext = (void *)out_ext;
18331             out_header = (void *)out_ext;
18332             break;
18333         }
18334         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
18335         {
18336             VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18337             const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *)in_header;
18338             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
18339             out_ext->pNext = NULL;
18340             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
18341             out_header->pNext = (void *)out_ext;
18342             out_header = (void *)out_ext;
18343             break;
18344         }
18345         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
18346         {
18347             VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18348             const VkPhysicalDeviceSynchronization2Features32 *in_ext = (const VkPhysicalDeviceSynchronization2Features32 *)in_header;
18349             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
18350             out_ext->pNext = NULL;
18351             out_ext->synchronization2 = in_ext->synchronization2;
18352             out_header->pNext = (void *)out_ext;
18353             out_header = (void *)out_ext;
18354             break;
18355         }
18356         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
18357         {
18358             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18359             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *)in_header;
18360             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
18361             out_ext->pNext = NULL;
18362             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
18363             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
18364             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
18365             out_header->pNext = (void *)out_ext;
18366             out_header = (void *)out_ext;
18367             break;
18368         }
18369         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
18370         {
18371             VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18372             const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *)in_header;
18373             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
18374             out_ext->pNext = NULL;
18375             out_ext->legacyDithering = in_ext->legacyDithering;
18376             out_header->pNext = (void *)out_ext;
18377             out_header = (void *)out_ext;
18378             break;
18379         }
18380         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
18381         {
18382             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18383             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *)in_header;
18384             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
18385             out_ext->pNext = NULL;
18386             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
18387             out_header->pNext = (void *)out_ext;
18388             out_header = (void *)out_ext;
18389             break;
18390         }
18391         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
18392         {
18393             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18394             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *)in_header;
18395             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
18396             out_ext->pNext = NULL;
18397             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
18398             out_header->pNext = (void *)out_ext;
18399             out_header = (void *)out_ext;
18400             break;
18401         }
18402         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
18403         {
18404             VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18405             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *)in_header;
18406             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
18407             out_ext->pNext = NULL;
18408             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
18409             out_header->pNext = (void *)out_ext;
18410             out_header = (void *)out_ext;
18411             break;
18412         }
18413         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
18414         {
18415             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18416             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *)in_header;
18417             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
18418             out_ext->pNext = NULL;
18419             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
18420             out_header->pNext = (void *)out_ext;
18421             out_header = (void *)out_ext;
18422             break;
18423         }
18424         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
18425         {
18426             VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18427             const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *)in_header;
18428             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
18429             out_ext->pNext = NULL;
18430             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
18431             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
18432             out_header->pNext = (void *)out_ext;
18433             out_header = (void *)out_ext;
18434             break;
18435         }
18436         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
18437         {
18438             VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18439             const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *)in_header;
18440             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
18441             out_ext->pNext = NULL;
18442             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
18443             out_header->pNext = (void *)out_ext;
18444             out_header = (void *)out_ext;
18445             break;
18446         }
18447         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
18448         {
18449             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18450             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *)in_header;
18451             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
18452             out_ext->pNext = NULL;
18453             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
18454             out_header->pNext = (void *)out_ext;
18455             out_header = (void *)out_ext;
18456             break;
18457         }
18458         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
18459         {
18460             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18461             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *)in_header;
18462             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
18463             out_ext->pNext = NULL;
18464             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
18465             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
18466             out_header->pNext = (void *)out_ext;
18467             out_header = (void *)out_ext;
18468             break;
18469         }
18470         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
18471         {
18472             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18473             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *)in_header;
18474             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
18475             out_ext->pNext = NULL;
18476             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
18477             out_header->pNext = (void *)out_ext;
18478             out_header = (void *)out_ext;
18479             break;
18480         }
18481         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
18482         {
18483             VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18484             const VkPhysicalDeviceDynamicRenderingFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures32 *)in_header;
18485             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
18486             out_ext->pNext = NULL;
18487             out_ext->dynamicRendering = in_ext->dynamicRendering;
18488             out_header->pNext = (void *)out_ext;
18489             out_header = (void *)out_ext;
18490             break;
18491         }
18492         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
18493         {
18494             VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18495             const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *)in_header;
18496             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
18497             out_ext->pNext = NULL;
18498             out_ext->minLod = in_ext->minLod;
18499             out_header->pNext = (void *)out_ext;
18500             out_header = (void *)out_ext;
18501             break;
18502         }
18503         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
18504         {
18505             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18506             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *)in_header;
18507             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
18508             out_ext->pNext = NULL;
18509             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
18510             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
18511             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
18512             out_header->pNext = (void *)out_ext;
18513             out_header = (void *)out_ext;
18514             break;
18515         }
18516         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
18517         {
18518             VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18519             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *)in_header;
18520             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
18521             out_ext->pNext = NULL;
18522             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
18523             out_header->pNext = (void *)out_ext;
18524             out_header = (void *)out_ext;
18525             break;
18526         }
18527         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
18528         {
18529             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18530             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *)in_header;
18531             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
18532             out_ext->pNext = NULL;
18533             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
18534             out_header->pNext = (void *)out_ext;
18535             out_header = (void *)out_ext;
18536             break;
18537         }
18538         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
18539         {
18540             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18541             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *)in_header;
18542             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
18543             out_ext->pNext = NULL;
18544             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
18545             out_header->pNext = (void *)out_ext;
18546             out_header = (void *)out_ext;
18547             break;
18548         }
18549         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
18550         {
18551             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18552             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *)in_header;
18553             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
18554             out_ext->pNext = NULL;
18555             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
18556             out_header->pNext = (void *)out_ext;
18557             out_header = (void *)out_ext;
18558             break;
18559         }
18560         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
18561         {
18562             VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18563             const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *)in_header;
18564             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
18565             out_ext->pNext = NULL;
18566             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
18567             out_header->pNext = (void *)out_ext;
18568             out_header = (void *)out_ext;
18569             break;
18570         }
18571         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
18572         {
18573             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18574             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *)in_header;
18575             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
18576             out_ext->pNext = NULL;
18577             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
18578             out_header->pNext = (void *)out_ext;
18579             out_header = (void *)out_ext;
18580             break;
18581         }
18582         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
18583         {
18584             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18585             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *)in_header;
18586             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
18587             out_ext->pNext = NULL;
18588             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
18589             out_header->pNext = (void *)out_ext;
18590             out_header = (void *)out_ext;
18591             break;
18592         }
18593         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
18594         {
18595             VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18596             const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *)in_header;
18597             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
18598             out_ext->pNext = NULL;
18599             out_ext->micromap = in_ext->micromap;
18600             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
18601             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
18602             out_header->pNext = (void *)out_ext;
18603             out_header = (void *)out_ext;
18604             break;
18605         }
18606         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
18607         {
18608             VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18609             const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *)in_header;
18610             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
18611             out_ext->pNext = NULL;
18612             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
18613             out_header->pNext = (void *)out_ext;
18614             out_header = (void *)out_ext;
18615             break;
18616         }
18617         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
18618         {
18619             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18620             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *)in_header;
18621             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
18622             out_ext->pNext = NULL;
18623             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
18624             out_header->pNext = (void *)out_ext;
18625             out_header = (void *)out_ext;
18626             break;
18627         }
18628         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
18629         {
18630             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18631             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *)in_header;
18632             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
18633             out_ext->pNext = NULL;
18634             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
18635             out_header->pNext = (void *)out_ext;
18636             out_header = (void *)out_ext;
18637             break;
18638         }
18639         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
18640         {
18641             VkPhysicalDevicePipelineRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18642             const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *)in_header;
18643             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
18644             out_ext->pNext = NULL;
18645             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
18646             out_header->pNext = (void *)out_ext;
18647             out_header = (void *)out_ext;
18648             break;
18649         }
18650         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
18651         {
18652             VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18653             const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *)in_header;
18654             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
18655             out_ext->pNext = NULL;
18656             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
18657             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
18658             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
18659             out_header->pNext = (void *)out_ext;
18660             out_header = (void *)out_ext;
18661             break;
18662         }
18663         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
18664         {
18665             VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18666             const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *)in_header;
18667             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
18668             out_ext->pNext = NULL;
18669             out_ext->tileProperties = in_ext->tileProperties;
18670             out_header->pNext = (void *)out_ext;
18671             out_header = (void *)out_ext;
18672             break;
18673         }
18674         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
18675         {
18676             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18677             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *)in_header;
18678             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
18679             out_ext->pNext = NULL;
18680             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
18681             out_header->pNext = (void *)out_ext;
18682             out_header = (void *)out_ext;
18683             break;
18684         }
18685         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
18686         {
18687             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18688             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *)in_header;
18689             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
18690             out_ext->pNext = NULL;
18691             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
18692             out_header->pNext = (void *)out_ext;
18693             out_header = (void *)out_ext;
18694             break;
18695         }
18696         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
18697         {
18698             VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18699             const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *)in_header;
18700             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
18701             out_ext->pNext = NULL;
18702             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
18703             out_header->pNext = (void *)out_ext;
18704             out_header = (void *)out_ext;
18705             break;
18706         }
18707         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
18708         {
18709             VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18710             const VkPhysicalDeviceOpticalFlowFeaturesNV32 *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV32 *)in_header;
18711             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
18712             out_ext->pNext = NULL;
18713             out_ext->opticalFlow = in_ext->opticalFlow;
18714             out_header->pNext = (void *)out_ext;
18715             out_header = (void *)out_ext;
18716             break;
18717         }
18718         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
18719         {
18720             VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18721             const VkPhysicalDeviceFaultFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT32 *)in_header;
18722             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
18723             out_ext->pNext = NULL;
18724             out_ext->deviceFault = in_ext->deviceFault;
18725             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
18726             out_header->pNext = (void *)out_ext;
18727             out_header = (void *)out_ext;
18728             break;
18729         }
18730         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
18731         {
18732             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18733             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *)in_header;
18734             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
18735             out_ext->pNext = NULL;
18736             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
18737             out_header->pNext = (void *)out_ext;
18738             out_header = (void *)out_ext;
18739             break;
18740         }
18741         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
18742         {
18743             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18744             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *)in_header;
18745             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
18746             out_ext->pNext = NULL;
18747             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
18748             out_header->pNext = (void *)out_ext;
18749             out_header = (void *)out_ext;
18750             break;
18751         }
18752         default:
18753             FIXME("Unhandled sType %u.", in_header->sType);
18754             break;
18755         }
18756     }
18757 }
18758 #endif /* USE_STRUCT_CONVERSION */
18759
18760 #if defined(USE_STRUCT_CONVERSION)
18761 static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDeviceFeatures2 *in, VkPhysicalDeviceFeatures232 *out)
18762 {
18763     const VkBaseInStructure *in_header;
18764     VkBaseOutStructure *out_header = (void *)out;
18765
18766     if (!in) return;
18767
18768     out->features = in->features;
18769
18770     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
18771     {
18772         switch (in_header->sType)
18773         {
18774         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
18775         {
18776             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV);
18777             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header;
18778             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
18779             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
18780             out_header = (void *)out_ext;
18781             break;
18782         }
18783         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
18784         {
18785             VkPhysicalDevicePrivateDataFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES);
18786             const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header;
18787             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
18788             out_ext->privateData = in_ext->privateData;
18789             out_header = (void *)out_ext;
18790             break;
18791         }
18792         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
18793         {
18794             VkPhysicalDeviceVariablePointersFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
18795             const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header;
18796             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
18797             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
18798             out_ext->variablePointers = in_ext->variablePointers;
18799             out_header = (void *)out_ext;
18800             break;
18801         }
18802         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
18803         {
18804             VkPhysicalDeviceMultiviewFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
18805             const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header;
18806             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
18807             out_ext->multiview = in_ext->multiview;
18808             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
18809             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
18810             out_header = (void *)out_ext;
18811             break;
18812         }
18813         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
18814         {
18815             VkPhysicalDevicePresentIdFeaturesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR);
18816             const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header;
18817             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
18818             out_ext->presentId = in_ext->presentId;
18819             out_header = (void *)out_ext;
18820             break;
18821         }
18822         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
18823         {
18824             VkPhysicalDevicePresentWaitFeaturesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR);
18825             const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header;
18826             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
18827             out_ext->presentWait = in_ext->presentWait;
18828             out_header = (void *)out_ext;
18829             break;
18830         }
18831         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
18832         {
18833             VkPhysicalDevice16BitStorageFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
18834             const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header;
18835             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
18836             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
18837             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
18838             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
18839             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
18840             out_header = (void *)out_ext;
18841             break;
18842         }
18843         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
18844         {
18845             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
18846             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header;
18847             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
18848             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
18849             out_header = (void *)out_ext;
18850             break;
18851         }
18852         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
18853         {
18854             VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
18855             const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header;
18856             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
18857             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
18858             out_header = (void *)out_ext;
18859             break;
18860         }
18861         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
18862         {
18863             VkPhysicalDeviceProtectedMemoryFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
18864             const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header;
18865             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
18866             out_ext->protectedMemory = in_ext->protectedMemory;
18867             out_header = (void *)out_ext;
18868             break;
18869         }
18870         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
18871         {
18872             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT);
18873             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)in_header;
18874             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
18875             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
18876             out_header = (void *)out_ext;
18877             break;
18878         }
18879         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
18880         {
18881             VkPhysicalDeviceMultiDrawFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT);
18882             const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header;
18883             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
18884             out_ext->multiDraw = in_ext->multiDraw;
18885             out_header = (void *)out_ext;
18886             break;
18887         }
18888         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
18889         {
18890             VkPhysicalDeviceInlineUniformBlockFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES);
18891             const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header;
18892             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
18893             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
18894             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
18895             out_header = (void *)out_ext;
18896             break;
18897         }
18898         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
18899         {
18900             VkPhysicalDeviceMaintenance4Features32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES);
18901             const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header;
18902             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
18903             out_ext->maintenance4 = in_ext->maintenance4;
18904             out_header = (void *)out_ext;
18905             break;
18906         }
18907         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
18908         {
18909             VkPhysicalDeviceShaderDrawParametersFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
18910             const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header;
18911             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
18912             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
18913             out_header = (void *)out_ext;
18914             break;
18915         }
18916         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
18917         {
18918             VkPhysicalDeviceShaderFloat16Int8Features32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
18919             const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header;
18920             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
18921             out_ext->shaderFloat16 = in_ext->shaderFloat16;
18922             out_ext->shaderInt8 = in_ext->shaderInt8;
18923             out_header = (void *)out_ext;
18924             break;
18925         }
18926         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
18927         {
18928             VkPhysicalDeviceHostQueryResetFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
18929             const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header;
18930             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
18931             out_ext->hostQueryReset = in_ext->hostQueryReset;
18932             out_header = (void *)out_ext;
18933             break;
18934         }
18935         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
18936         {
18937             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR);
18938             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *)in_header;
18939             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
18940             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
18941             out_header = (void *)out_ext;
18942             break;
18943         }
18944         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
18945         {
18946             VkPhysicalDeviceDescriptorIndexingFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
18947             const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header;
18948             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
18949             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
18950             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
18951             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
18952             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
18953             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
18954             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
18955             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
18956             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
18957             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
18958             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
18959             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
18960             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
18961             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
18962             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
18963             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
18964             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
18965             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
18966             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
18967             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
18968             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
18969             out_header = (void *)out_ext;
18970             break;
18971         }
18972         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
18973         {
18974             VkPhysicalDeviceTimelineSemaphoreFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
18975             const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header;
18976             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
18977             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
18978             out_header = (void *)out_ext;
18979             break;
18980         }
18981         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
18982         {
18983             VkPhysicalDevice8BitStorageFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
18984             const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header;
18985             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
18986             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
18987             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
18988             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
18989             out_header = (void *)out_ext;
18990             break;
18991         }
18992         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
18993         {
18994             VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT);
18995             const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header;
18996             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
18997             out_ext->conditionalRendering = in_ext->conditionalRendering;
18998             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
18999             out_header = (void *)out_ext;
19000             break;
19001         }
19002         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
19003         {
19004             VkPhysicalDeviceVulkanMemoryModelFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
19005             const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header;
19006             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
19007             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
19008             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
19009             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
19010             out_header = (void *)out_ext;
19011             break;
19012         }
19013         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
19014         {
19015             VkPhysicalDeviceShaderAtomicInt64Features32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
19016             const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header;
19017             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
19018             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
19019             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
19020             out_header = (void *)out_ext;
19021             break;
19022         }
19023         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
19024         {
19025             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT);
19026             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header;
19027             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
19028             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
19029             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
19030             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
19031             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
19032             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
19033             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
19034             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
19035             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
19036             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
19037             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
19038             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
19039             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
19040             out_header = (void *)out_ext;
19041             break;
19042         }
19043         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
19044         {
19045             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT);
19046             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header;
19047             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
19048             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
19049             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
19050             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
19051             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
19052             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
19053             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
19054             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
19055             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
19056             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
19057             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
19058             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
19059             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
19060             out_header = (void *)out_ext;
19061             break;
19062         }
19063         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
19064         {
19065             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT);
19066             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)in_header;
19067             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
19068             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
19069             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
19070             out_header = (void *)out_ext;
19071             break;
19072         }
19073         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
19074         {
19075             VkPhysicalDeviceASTCDecodeFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT);
19076             const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header;
19077             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
19078             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
19079             out_header = (void *)out_ext;
19080             break;
19081         }
19082         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
19083         {
19084             VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
19085             const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header;
19086             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
19087             out_ext->transformFeedback = in_ext->transformFeedback;
19088             out_ext->geometryStreams = in_ext->geometryStreams;
19089             out_header = (void *)out_ext;
19090             break;
19091         }
19092         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
19093         {
19094             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV);
19095             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header;
19096             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
19097             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
19098             out_header = (void *)out_ext;
19099             break;
19100         }
19101         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
19102         {
19103             VkPhysicalDeviceExclusiveScissorFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV);
19104             const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header;
19105             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
19106             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
19107             out_header = (void *)out_ext;
19108             break;
19109         }
19110         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
19111         {
19112             VkPhysicalDeviceCornerSampledImageFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV);
19113             const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header;
19114             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
19115             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
19116             out_header = (void *)out_ext;
19117             break;
19118         }
19119         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
19120         {
19121             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV);
19122             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *)in_header;
19123             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
19124             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
19125             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
19126             out_header = (void *)out_ext;
19127             break;
19128         }
19129         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
19130         {
19131             VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV);
19132             const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header;
19133             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
19134             out_ext->imageFootprint = in_ext->imageFootprint;
19135             out_header = (void *)out_ext;
19136             break;
19137         }
19138         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
19139         {
19140             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV);
19141             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header;
19142             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
19143             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
19144             out_header = (void *)out_ext;
19145             break;
19146         }
19147         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
19148         {
19149             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV);
19150             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header;
19151             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
19152             out_ext->indirectCopy = in_ext->indirectCopy;
19153             out_header = (void *)out_ext;
19154             break;
19155         }
19156         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
19157         {
19158             VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV);
19159             const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header;
19160             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
19161             out_ext->memoryDecompression = in_ext->memoryDecompression;
19162             out_header = (void *)out_ext;
19163             break;
19164         }
19165         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
19166         {
19167             VkPhysicalDeviceShadingRateImageFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV);
19168             const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header;
19169             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
19170             out_ext->shadingRateImage = in_ext->shadingRateImage;
19171             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
19172             out_header = (void *)out_ext;
19173             break;
19174         }
19175         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
19176         {
19177             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI);
19178             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header;
19179             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
19180             out_ext->invocationMask = in_ext->invocationMask;
19181             out_header = (void *)out_ext;
19182             break;
19183         }
19184         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
19185         {
19186             VkPhysicalDeviceMeshShaderFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV);
19187             const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header;
19188             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
19189             out_ext->taskShader = in_ext->taskShader;
19190             out_ext->meshShader = in_ext->meshShader;
19191             out_header = (void *)out_ext;
19192             break;
19193         }
19194         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
19195         {
19196             VkPhysicalDeviceMeshShaderFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT);
19197             const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header;
19198             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
19199             out_ext->taskShader = in_ext->taskShader;
19200             out_ext->meshShader = in_ext->meshShader;
19201             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
19202             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
19203             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
19204             out_header = (void *)out_ext;
19205             break;
19206         }
19207         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
19208         {
19209             VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR);
19210             const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header;
19211             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
19212             out_ext->accelerationStructure = in_ext->accelerationStructure;
19213             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
19214             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
19215             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
19216             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
19217             out_header = (void *)out_ext;
19218             break;
19219         }
19220         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
19221         {
19222             VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR);
19223             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header;
19224             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
19225             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
19226             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
19227             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
19228             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
19229             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
19230             out_header = (void *)out_ext;
19231             break;
19232         }
19233         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
19234         {
19235             VkPhysicalDeviceRayQueryFeaturesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR);
19236             const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header;
19237             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
19238             out_ext->rayQuery = in_ext->rayQuery;
19239             out_header = (void *)out_ext;
19240             break;
19241         }
19242         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
19243         {
19244             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR);
19245             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header;
19246             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
19247             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
19248             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
19249             out_header = (void *)out_ext;
19250             break;
19251         }
19252         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
19253         {
19254             VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT);
19255             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)in_header;
19256             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
19257             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
19258             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
19259             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
19260             out_header = (void *)out_ext;
19261             break;
19262         }
19263         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
19264         {
19265             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT);
19266             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header;
19267             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
19268             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
19269             out_header = (void *)out_ext;
19270             break;
19271         }
19272         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
19273         {
19274             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM);
19275             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *)in_header;
19276             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
19277             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
19278             out_header = (void *)out_ext;
19279             break;
19280         }
19281         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
19282         {
19283             VkPhysicalDeviceScalarBlockLayoutFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
19284             const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header;
19285             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
19286             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
19287             out_header = (void *)out_ext;
19288             break;
19289         }
19290         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
19291         {
19292             VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
19293             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header;
19294             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
19295             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
19296             out_header = (void *)out_ext;
19297             break;
19298         }
19299         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
19300         {
19301             VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT);
19302             const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header;
19303             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
19304             out_ext->depthClipEnable = in_ext->depthClipEnable;
19305             out_header = (void *)out_ext;
19306             break;
19307         }
19308         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
19309         {
19310             VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT);
19311             const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header;
19312             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
19313             out_ext->memoryPriority = in_ext->memoryPriority;
19314             out_header = (void *)out_ext;
19315             break;
19316         }
19317         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
19318         {
19319             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT);
19320             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header;
19321             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
19322             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
19323             out_header = (void *)out_ext;
19324             break;
19325         }
19326         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
19327         {
19328             VkPhysicalDeviceBufferDeviceAddressFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
19329             const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header;
19330             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
19331             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
19332             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
19333             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
19334             out_header = (void *)out_ext;
19335             break;
19336         }
19337         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
19338         {
19339             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT);
19340             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header;
19341             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
19342             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
19343             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
19344             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
19345             out_header = (void *)out_ext;
19346             break;
19347         }
19348         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
19349         {
19350             VkPhysicalDeviceImagelessFramebufferFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
19351             const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header;
19352             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
19353             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
19354             out_header = (void *)out_ext;
19355             break;
19356         }
19357         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
19358         {
19359             VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES);
19360             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header;
19361             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
19362             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
19363             out_header = (void *)out_ext;
19364             break;
19365         }
19366         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
19367         {
19368             VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV);
19369             const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header;
19370             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
19371             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
19372             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
19373             out_header = (void *)out_ext;
19374             break;
19375         }
19376         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
19377         {
19378             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT);
19379             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header;
19380             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
19381             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
19382             out_header = (void *)out_ext;
19383             break;
19384         }
19385         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
19386         {
19387             VkPhysicalDevicePresentBarrierFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV);
19388             const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header;
19389             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
19390             out_ext->presentBarrier = in_ext->presentBarrier;
19391             out_header = (void *)out_ext;
19392             break;
19393         }
19394         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
19395         {
19396             VkPhysicalDevicePerformanceQueryFeaturesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR);
19397             const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header;
19398             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
19399             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
19400             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
19401             out_header = (void *)out_ext;
19402             break;
19403         }
19404         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
19405         {
19406             VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV);
19407             const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header;
19408             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
19409             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
19410             out_header = (void *)out_ext;
19411             break;
19412         }
19413         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
19414         {
19415             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL);
19416             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header;
19417             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
19418             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
19419             out_header = (void *)out_ext;
19420             break;
19421         }
19422         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
19423         {
19424             VkPhysicalDeviceShaderClockFeaturesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR);
19425             const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header;
19426             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
19427             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
19428             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
19429             out_header = (void *)out_ext;
19430             break;
19431         }
19432         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
19433         {
19434             VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT);
19435             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)in_header;
19436             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
19437             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
19438             out_header = (void *)out_ext;
19439             break;
19440         }
19441         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
19442         {
19443             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV);
19444             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header;
19445             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
19446             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
19447             out_header = (void *)out_ext;
19448             break;
19449         }
19450         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
19451         {
19452             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT);
19453             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header;
19454             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
19455             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
19456             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
19457             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
19458             out_header = (void *)out_ext;
19459             break;
19460         }
19461         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
19462         {
19463             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
19464             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header;
19465             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
19466             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
19467             out_header = (void *)out_ext;
19468             break;
19469         }
19470         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
19471         {
19472             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT);
19473             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header;
19474             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
19475             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
19476             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
19477             out_header = (void *)out_ext;
19478             break;
19479         }
19480         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
19481         {
19482             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR);
19483             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header;
19484             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
19485             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
19486             out_header = (void *)out_ext;
19487             break;
19488         }
19489         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
19490         {
19491             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES);
19492             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header;
19493             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
19494             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
19495             out_header = (void *)out_ext;
19496             break;
19497         }
19498         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
19499         {
19500             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT);
19501             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header;
19502             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
19503             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
19504             out_header = (void *)out_ext;
19505             break;
19506         }
19507         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
19508         {
19509             VkPhysicalDeviceSubgroupSizeControlFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES);
19510             const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header;
19511             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
19512             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
19513             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
19514             out_header = (void *)out_ext;
19515             break;
19516         }
19517         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
19518         {
19519             VkPhysicalDeviceLineRasterizationFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT);
19520             const VkPhysicalDeviceLineRasterizationFeaturesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)in_header;
19521             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
19522             out_ext->rectangularLines = in_ext->rectangularLines;
19523             out_ext->bresenhamLines = in_ext->bresenhamLines;
19524             out_ext->smoothLines = in_ext->smoothLines;
19525             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
19526             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
19527             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
19528             out_header = (void *)out_ext;
19529             break;
19530         }
19531         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
19532         {
19533             VkPhysicalDevicePipelineCreationCacheControlFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES);
19534             const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header;
19535             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
19536             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
19537             out_header = (void *)out_ext;
19538             break;
19539         }
19540         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
19541         {
19542             VkPhysicalDeviceVulkan11Features32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
19543             const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header;
19544             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
19545             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
19546             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
19547             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
19548             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
19549             out_ext->multiview = in_ext->multiview;
19550             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
19551             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
19552             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
19553             out_ext->variablePointers = in_ext->variablePointers;
19554             out_ext->protectedMemory = in_ext->protectedMemory;
19555             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
19556             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
19557             out_header = (void *)out_ext;
19558             break;
19559         }
19560         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
19561         {
19562             VkPhysicalDeviceVulkan12Features32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
19563             const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header;
19564             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
19565             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
19566             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
19567             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
19568             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
19569             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
19570             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
19571             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
19572             out_ext->shaderFloat16 = in_ext->shaderFloat16;
19573             out_ext->shaderInt8 = in_ext->shaderInt8;
19574             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
19575             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
19576             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
19577             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
19578             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
19579             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
19580             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
19581             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
19582             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
19583             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
19584             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
19585             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
19586             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
19587             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
19588             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
19589             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
19590             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
19591             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
19592             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
19593             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
19594             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
19595             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
19596             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
19597             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
19598             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
19599             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
19600             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
19601             out_ext->hostQueryReset = in_ext->hostQueryReset;
19602             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
19603             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
19604             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
19605             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
19606             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
19607             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
19608             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
19609             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
19610             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
19611             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
19612             out_header = (void *)out_ext;
19613             break;
19614         }
19615         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
19616         {
19617             VkPhysicalDeviceVulkan13Features32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES);
19618             const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header;
19619             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
19620             out_ext->robustImageAccess = in_ext->robustImageAccess;
19621             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
19622             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
19623             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
19624             out_ext->privateData = in_ext->privateData;
19625             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
19626             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
19627             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
19628             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
19629             out_ext->synchronization2 = in_ext->synchronization2;
19630             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
19631             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
19632             out_ext->dynamicRendering = in_ext->dynamicRendering;
19633             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
19634             out_ext->maintenance4 = in_ext->maintenance4;
19635             out_header = (void *)out_ext;
19636             break;
19637         }
19638         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
19639         {
19640             VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD);
19641             const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header;
19642             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
19643             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
19644             out_header = (void *)out_ext;
19645             break;
19646         }
19647         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
19648         {
19649             VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT);
19650             const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header;
19651             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
19652             out_ext->customBorderColors = in_ext->customBorderColors;
19653             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
19654             out_header = (void *)out_ext;
19655             break;
19656         }
19657         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
19658         {
19659             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT);
19660             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header;
19661             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
19662             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
19663             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
19664             out_header = (void *)out_ext;
19665             break;
19666         }
19667         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
19668         {
19669             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT);
19670             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header;
19671             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
19672             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
19673             out_header = (void *)out_ext;
19674             break;
19675         }
19676         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
19677         {
19678             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT);
19679             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header;
19680             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
19681             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
19682             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
19683             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
19684             out_header = (void *)out_ext;
19685             break;
19686         }
19687         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
19688         {
19689             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT);
19690             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header;
19691             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
19692             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
19693             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
19694             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
19695             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
19696             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
19697             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
19698             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
19699             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
19700             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
19701             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
19702             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
19703             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
19704             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
19705             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
19706             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
19707             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
19708             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
19709             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
19710             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
19711             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
19712             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
19713             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
19714             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
19715             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
19716             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
19717             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
19718             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
19719             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
19720             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
19721             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
19722             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
19723             out_header = (void *)out_ext;
19724             break;
19725         }
19726         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
19727         {
19728             VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV);
19729             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header;
19730             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
19731             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
19732             out_header = (void *)out_ext;
19733             break;
19734         }
19735         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
19736         {
19737             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES);
19738             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header;
19739             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
19740             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
19741             out_header = (void *)out_ext;
19742             break;
19743         }
19744         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
19745         {
19746             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR);
19747             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header;
19748             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
19749             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
19750             out_header = (void *)out_ext;
19751             break;
19752         }
19753         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
19754         {
19755             VkPhysicalDeviceRobustness2FeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT);
19756             const VkPhysicalDeviceRobustness2FeaturesEXT *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT *)in_header;
19757             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
19758             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
19759             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
19760             out_ext->nullDescriptor = in_ext->nullDescriptor;
19761             out_header = (void *)out_ext;
19762             break;
19763         }
19764         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
19765         {
19766             VkPhysicalDeviceImageRobustnessFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES);
19767             const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header;
19768             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
19769             out_ext->robustImageAccess = in_ext->robustImageAccess;
19770             out_header = (void *)out_ext;
19771             break;
19772         }
19773         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
19774         {
19775             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR);
19776             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header;
19777             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
19778             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
19779             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
19780             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
19781             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
19782             out_header = (void *)out_ext;
19783             break;
19784         }
19785         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
19786         {
19787             VkPhysicalDevice4444FormatsFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT);
19788             const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header;
19789             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
19790             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
19791             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
19792             out_header = (void *)out_ext;
19793             break;
19794         }
19795         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
19796         {
19797             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI);
19798             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header;
19799             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
19800             out_ext->subpassShading = in_ext->subpassShading;
19801             out_header = (void *)out_ext;
19802             break;
19803         }
19804         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
19805         {
19806             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT);
19807             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header;
19808             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
19809             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
19810             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
19811             out_header = (void *)out_ext;
19812             break;
19813         }
19814         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
19815         {
19816             VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR);
19817             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header;
19818             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
19819             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
19820             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
19821             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
19822             out_header = (void *)out_ext;
19823             break;
19824         }
19825         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
19826         {
19827             VkPhysicalDeviceShaderTerminateInvocationFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES);
19828             const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header;
19829             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
19830             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
19831             out_header = (void *)out_ext;
19832             break;
19833         }
19834         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
19835         {
19836             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV);
19837             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header;
19838             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
19839             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
19840             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
19841             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
19842             out_header = (void *)out_ext;
19843             break;
19844         }
19845         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
19846         {
19847             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT);
19848             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header;
19849             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
19850             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
19851             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
19852             out_header = (void *)out_ext;
19853             break;
19854         }
19855         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
19856         {
19857             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT);
19858             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header;
19859             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
19860             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
19861             out_header = (void *)out_ext;
19862             break;
19863         }
19864         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
19865         {
19866             VkPhysicalDeviceDepthClipControlFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT);
19867             const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header;
19868             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
19869             out_ext->depthClipControl = in_ext->depthClipControl;
19870             out_header = (void *)out_ext;
19871             break;
19872         }
19873         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
19874         {
19875             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT);
19876             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header;
19877             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
19878             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
19879             out_header = (void *)out_ext;
19880             break;
19881         }
19882         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
19883         {
19884             VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT);
19885             const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header;
19886             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
19887             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
19888             out_header = (void *)out_ext;
19889             break;
19890         }
19891         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
19892         {
19893             VkPhysicalDeviceSynchronization2Features32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES);
19894             const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header;
19895             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
19896             out_ext->synchronization2 = in_ext->synchronization2;
19897             out_header = (void *)out_ext;
19898             break;
19899         }
19900         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
19901         {
19902             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT);
19903             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header;
19904             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
19905             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
19906             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
19907             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
19908             out_header = (void *)out_ext;
19909             break;
19910         }
19911         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
19912         {
19913             VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT);
19914             const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header;
19915             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
19916             out_ext->legacyDithering = in_ext->legacyDithering;
19917             out_header = (void *)out_ext;
19918             break;
19919         }
19920         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
19921         {
19922             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT);
19923             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header;
19924             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
19925             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
19926             out_header = (void *)out_ext;
19927             break;
19928         }
19929         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
19930         {
19931             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT);
19932             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *)in_header;
19933             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
19934             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
19935             out_header = (void *)out_ext;
19936             break;
19937         }
19938         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
19939         {
19940             VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV);
19941             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header;
19942             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
19943             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
19944             out_header = (void *)out_ext;
19945             break;
19946         }
19947         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
19948         {
19949             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT);
19950             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header;
19951             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
19952             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
19953             out_header = (void *)out_ext;
19954             break;
19955         }
19956         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
19957         {
19958             VkPhysicalDeviceProvokingVertexFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT);
19959             const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header;
19960             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
19961             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
19962             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
19963             out_header = (void *)out_ext;
19964             break;
19965         }
19966         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
19967         {
19968             VkPhysicalDeviceShaderIntegerDotProductFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES);
19969             const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header;
19970             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
19971             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
19972             out_header = (void *)out_ext;
19973             break;
19974         }
19975         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
19976         {
19977             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR);
19978             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header;
19979             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
19980             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
19981             out_header = (void *)out_ext;
19982             break;
19983         }
19984         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
19985         {
19986             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV);
19987             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header;
19988             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
19989             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
19990             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
19991             out_header = (void *)out_ext;
19992             break;
19993         }
19994         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
19995         {
19996             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT);
19997             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header;
19998             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
19999             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
20000             out_header = (void *)out_ext;
20001             break;
20002         }
20003         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
20004         {
20005             VkPhysicalDeviceDynamicRenderingFeatures32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES);
20006             const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header;
20007             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
20008             out_ext->dynamicRendering = in_ext->dynamicRendering;
20009             out_header = (void *)out_ext;
20010             break;
20011         }
20012         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
20013         {
20014             VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT);
20015             const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header;
20016             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
20017             out_ext->minLod = in_ext->minLod;
20018             out_header = (void *)out_ext;
20019             break;
20020         }
20021         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
20022         {
20023             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT);
20024             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header;
20025             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
20026             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
20027             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
20028             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
20029             out_header = (void *)out_ext;
20030             break;
20031         }
20032         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
20033         {
20034             VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV);
20035             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header;
20036             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
20037             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
20038             out_header = (void *)out_ext;
20039             break;
20040         }
20041         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
20042         {
20043             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT);
20044             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header;
20045             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
20046             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
20047             out_header = (void *)out_ext;
20048             break;
20049         }
20050         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
20051         {
20052             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE);
20053             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header;
20054             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
20055             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
20056             out_header = (void *)out_ext;
20057             break;
20058         }
20059         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
20060         {
20061             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT);
20062             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header;
20063             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
20064             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
20065             out_header = (void *)out_ext;
20066             break;
20067         }
20068         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
20069         {
20070             VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT);
20071             const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header;
20072             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
20073             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
20074             out_header = (void *)out_ext;
20075             break;
20076         }
20077         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
20078         {
20079             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT);
20080             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header;
20081             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
20082             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
20083             out_header = (void *)out_ext;
20084             break;
20085         }
20086         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
20087         {
20088             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT);
20089             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header;
20090             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
20091             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
20092             out_header = (void *)out_ext;
20093             break;
20094         }
20095         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
20096         {
20097             VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT);
20098             const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header;
20099             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
20100             out_ext->micromap = in_ext->micromap;
20101             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
20102             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
20103             out_header = (void *)out_ext;
20104             break;
20105         }
20106         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
20107         {
20108             VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT);
20109             const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header;
20110             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
20111             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
20112             out_header = (void *)out_ext;
20113             break;
20114         }
20115         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
20116         {
20117             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD);
20118             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *)in_header;
20119             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
20120             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
20121             out_header = (void *)out_ext;
20122             break;
20123         }
20124         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
20125         {
20126             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT);
20127             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header;
20128             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
20129             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
20130             out_header = (void *)out_ext;
20131             break;
20132         }
20133         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
20134         {
20135             VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT);
20136             const VkPhysicalDevicePipelineRobustnessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT *)in_header;
20137             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
20138             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
20139             out_header = (void *)out_ext;
20140             break;
20141         }
20142         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
20143         {
20144             VkPhysicalDeviceImageProcessingFeaturesQCOM32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM);
20145             const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header;
20146             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
20147             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
20148             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
20149             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
20150             out_header = (void *)out_ext;
20151             break;
20152         }
20153         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
20154         {
20155             VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM);
20156             const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header;
20157             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
20158             out_ext->tileProperties = in_ext->tileProperties;
20159             out_header = (void *)out_ext;
20160             break;
20161         }
20162         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
20163         {
20164             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT);
20165             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header;
20166             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
20167             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
20168             out_header = (void *)out_ext;
20169             break;
20170         }
20171         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
20172         {
20173             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT);
20174             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *)in_header;
20175             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
20176             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
20177             out_header = (void *)out_ext;
20178             break;
20179         }
20180         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
20181         {
20182             VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT);
20183             const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header;
20184             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
20185             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
20186             out_header = (void *)out_ext;
20187             break;
20188         }
20189         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
20190         {
20191             VkPhysicalDeviceOpticalFlowFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV);
20192             const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header;
20193             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
20194             out_ext->opticalFlow = in_ext->opticalFlow;
20195             out_header = (void *)out_ext;
20196             break;
20197         }
20198         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
20199         {
20200             VkPhysicalDeviceFaultFeaturesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT);
20201             const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header;
20202             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
20203             out_ext->deviceFault = in_ext->deviceFault;
20204             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
20205             out_header = (void *)out_ext;
20206             break;
20207         }
20208         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
20209         {
20210             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM);
20211             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header;
20212             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
20213             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
20214             out_header = (void *)out_ext;
20215             break;
20216         }
20217         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
20218         {
20219             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV);
20220             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header;
20221             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
20222             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
20223             out_header = (void *)out_ext;
20224             break;
20225         }
20226         default:
20227             break;
20228         }
20229     }
20230 }
20231 #endif /* USE_STRUCT_CONVERSION */
20232
20233 #if defined(USE_STRUCT_CONVERSION)
20234 static inline void convert_VkFormatProperties2_win32_to_host(struct conversion_context *ctx, const VkFormatProperties232 *in, VkFormatProperties2 *out)
20235 {
20236     const VkBaseInStructure *in_header;
20237     VkBaseOutStructure *out_header = (void *)out;
20238
20239     if (!in) return;
20240
20241     out->sType = in->sType;
20242     out->pNext = NULL;
20243
20244     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
20245     {
20246         switch (in_header->sType)
20247         {
20248         case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
20249         {
20250             VkSubpassResolvePerformanceQueryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20251             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
20252             out_ext->pNext = NULL;
20253             out_header->pNext = (void *)out_ext;
20254             out_header = (void *)out_ext;
20255             break;
20256         }
20257         case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
20258         {
20259             VkFormatProperties3 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20260             out_ext->sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
20261             out_ext->pNext = NULL;
20262             out_header->pNext = (void *)out_ext;
20263             out_header = (void *)out_ext;
20264             break;
20265         }
20266         default:
20267             FIXME("Unhandled sType %u.", in_header->sType);
20268             break;
20269         }
20270     }
20271 }
20272 #endif /* USE_STRUCT_CONVERSION */
20273
20274 #if defined(USE_STRUCT_CONVERSION)
20275 static inline void convert_VkFormatProperties2_host_to_win32(const VkFormatProperties2 *in, VkFormatProperties232 *out)
20276 {
20277     const VkBaseInStructure *in_header;
20278     VkBaseOutStructure *out_header = (void *)out;
20279
20280     if (!in) return;
20281
20282     out->formatProperties = in->formatProperties;
20283
20284     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
20285     {
20286         switch (in_header->sType)
20287         {
20288         case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
20289         {
20290             VkSubpassResolvePerformanceQueryEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT);
20291             const VkSubpassResolvePerformanceQueryEXT *in_ext = (const VkSubpassResolvePerformanceQueryEXT *)in_header;
20292             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
20293             out_ext->optimal = in_ext->optimal;
20294             out_header = (void *)out_ext;
20295             break;
20296         }
20297         case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
20298         {
20299             VkFormatProperties332 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3);
20300             const VkFormatProperties3 *in_ext = (const VkFormatProperties3 *)in_header;
20301             out_ext->sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
20302             out_ext->linearTilingFeatures = in_ext->linearTilingFeatures;
20303             out_ext->optimalTilingFeatures = in_ext->optimalTilingFeatures;
20304             out_ext->bufferFeatures = in_ext->bufferFeatures;
20305             out_header = (void *)out_ext;
20306             break;
20307         }
20308         default:
20309             break;
20310         }
20311     }
20312 }
20313 #endif /* USE_STRUCT_CONVERSION */
20314
20315 #if defined(USE_STRUCT_CONVERSION)
20316 static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_win32_to_host(const VkPhysicalDeviceFragmentShadingRateKHR32 *in, VkPhysicalDeviceFragmentShadingRateKHR *out)
20317 {
20318     if (!in) return;
20319
20320     out->sType = in->sType;
20321     out->pNext = in->pNext;
20322 }
20323 #endif /* USE_STRUCT_CONVERSION */
20324
20325 #if defined(USE_STRUCT_CONVERSION)
20326 static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_host_to_win32(const VkPhysicalDeviceFragmentShadingRateKHR *in, VkPhysicalDeviceFragmentShadingRateKHR32 *out)
20327 {
20328     if (!in) return;
20329
20330     out->sampleCounts = in->sampleCounts;
20331     out->fragmentSize = in->fragmentSize;
20332 }
20333 #endif /* USE_STRUCT_CONVERSION */
20334
20335 #if defined(USE_STRUCT_CONVERSION)
20336 static inline VkPhysicalDeviceFragmentShadingRateKHR *convert_VkPhysicalDeviceFragmentShadingRateKHR_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceFragmentShadingRateKHR32 *in, uint32_t count)
20337 {
20338     VkPhysicalDeviceFragmentShadingRateKHR *out;
20339     unsigned int i;
20340
20341     if (!in || !count) return NULL;
20342
20343     out = conversion_context_alloc(ctx, count * sizeof(*out));
20344     for (i = 0; i < count; i++)
20345     {
20346         convert_VkPhysicalDeviceFragmentShadingRateKHR_win32_to_host(&in[i], &out[i]);
20347     }
20348
20349     return out;
20350 }
20351 #endif /* USE_STRUCT_CONVERSION */
20352
20353 #if defined(USE_STRUCT_CONVERSION)
20354 static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_array_host_to_win32(const VkPhysicalDeviceFragmentShadingRateKHR *in, VkPhysicalDeviceFragmentShadingRateKHR32 *out, uint32_t count)
20355 {
20356     unsigned int i;
20357
20358     if (!in) return;
20359
20360     for (i = 0; i < count; i++)
20361     {
20362         convert_VkPhysicalDeviceFragmentShadingRateKHR_host_to_win32(&in[i], &out[i]);
20363     }
20364 }
20365 #endif /* USE_STRUCT_CONVERSION */
20366
20367 #if defined(USE_STRUCT_CONVERSION)
20368 static inline void convert_VkImageFormatProperties_host_to_win32(const VkImageFormatProperties *in, VkImageFormatProperties32 *out)
20369 {
20370     if (!in) return;
20371
20372     out->maxExtent = in->maxExtent;
20373     out->maxMipLevels = in->maxMipLevels;
20374     out->maxArrayLayers = in->maxArrayLayers;
20375     out->sampleCounts = in->sampleCounts;
20376     out->maxResourceSize = in->maxResourceSize;
20377 }
20378 #endif /* USE_STRUCT_CONVERSION */
20379
20380 #if defined(USE_STRUCT_CONVERSION)
20381 static inline void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceImageFormatInfo232 *in, VkPhysicalDeviceImageFormatInfo2 *out)
20382 {
20383     const VkBaseInStructure *in_header;
20384     VkBaseOutStructure *out_header = (void *)out;
20385
20386     if (!in) return;
20387
20388     out->sType = in->sType;
20389     out->pNext = NULL;
20390     out->format = in->format;
20391     out->type = in->type;
20392     out->tiling = in->tiling;
20393     out->usage = in->usage;
20394     out->flags = in->flags;
20395
20396     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
20397     {
20398         switch (in_header->sType)
20399         {
20400         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
20401         {
20402             VkPhysicalDeviceExternalImageFormatInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20403             const VkPhysicalDeviceExternalImageFormatInfo32 *in_ext = (const VkPhysicalDeviceExternalImageFormatInfo32 *)in_header;
20404             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
20405             out_ext->pNext = NULL;
20406             out_ext->handleType = in_ext->handleType;
20407             out_header->pNext = (void *)out_ext;
20408             out_header = (void *)out_ext;
20409             break;
20410         }
20411         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
20412         {
20413             VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20414             const VkImageFormatListCreateInfo32 *in_ext = (const VkImageFormatListCreateInfo32 *)in_header;
20415             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
20416             out_ext->pNext = NULL;
20417             out_ext->viewFormatCount = in_ext->viewFormatCount;
20418             out_ext->pViewFormats = in_ext->pViewFormats;
20419             out_header->pNext = (void *)out_ext;
20420             out_header = (void *)out_ext;
20421             break;
20422         }
20423         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
20424         {
20425             VkImageStencilUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20426             const VkImageStencilUsageCreateInfo32 *in_ext = (const VkImageStencilUsageCreateInfo32 *)in_header;
20427             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO;
20428             out_ext->pNext = NULL;
20429             out_ext->stencilUsage = in_ext->stencilUsage;
20430             out_header->pNext = (void *)out_ext;
20431             out_header = (void *)out_ext;
20432             break;
20433         }
20434         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
20435         {
20436             VkPhysicalDeviceImageViewImageFormatInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20437             const VkPhysicalDeviceImageViewImageFormatInfoEXT32 *in_ext = (const VkPhysicalDeviceImageViewImageFormatInfoEXT32 *)in_header;
20438             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT;
20439             out_ext->pNext = NULL;
20440             out_ext->imageViewType = in_ext->imageViewType;
20441             out_header->pNext = (void *)out_ext;
20442             out_header = (void *)out_ext;
20443             break;
20444         }
20445         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
20446         {
20447             VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20448             const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
20449             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
20450             out_ext->pNext = NULL;
20451             out_ext->flags = in_ext->flags;
20452             out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
20453             out_ext->pFixedRateFlags = in_ext->pFixedRateFlags;
20454             out_header->pNext = (void *)out_ext;
20455             out_header = (void *)out_ext;
20456             break;
20457         }
20458         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
20459         {
20460             VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20461             const VkOpticalFlowImageFormatInfoNV32 *in_ext = (const VkOpticalFlowImageFormatInfoNV32 *)in_header;
20462             out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV;
20463             out_ext->pNext = NULL;
20464             out_ext->usage = in_ext->usage;
20465             out_header->pNext = (void *)out_ext;
20466             out_header = (void *)out_ext;
20467             break;
20468         }
20469         default:
20470             FIXME("Unhandled sType %u.", in_header->sType);
20471             break;
20472         }
20473     }
20474 }
20475 #endif /* USE_STRUCT_CONVERSION */
20476
20477 #if defined(USE_STRUCT_CONVERSION)
20478 static inline void convert_VkImageFormatProperties2_win32_to_host(struct conversion_context *ctx, const VkImageFormatProperties232 *in, VkImageFormatProperties2 *out)
20479 {
20480     const VkBaseInStructure *in_header;
20481     VkBaseOutStructure *out_header = (void *)out;
20482
20483     if (!in) return;
20484
20485     out->sType = in->sType;
20486     out->pNext = NULL;
20487
20488     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
20489     {
20490         switch (in_header->sType)
20491         {
20492         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
20493         {
20494             VkExternalImageFormatProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20495             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
20496             out_ext->pNext = NULL;
20497             out_header->pNext = (void *)out_ext;
20498             out_header = (void *)out_ext;
20499             break;
20500         }
20501         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
20502         {
20503             VkSamplerYcbcrConversionImageFormatProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20504             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
20505             out_ext->pNext = NULL;
20506             out_header->pNext = (void *)out_ext;
20507             out_header = (void *)out_ext;
20508             break;
20509         }
20510         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
20511         {
20512             VkTextureLODGatherFormatPropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20513             out_ext->sType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD;
20514             out_ext->pNext = NULL;
20515             out_header->pNext = (void *)out_ext;
20516             out_header = (void *)out_ext;
20517             break;
20518         }
20519         case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
20520         {
20521             VkFilterCubicImageViewImageFormatPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20522             out_ext->sType = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT;
20523             out_ext->pNext = NULL;
20524             out_header->pNext = (void *)out_ext;
20525             out_header = (void *)out_ext;
20526             break;
20527         }
20528         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
20529         {
20530             VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20531             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
20532             out_ext->pNext = NULL;
20533             out_header->pNext = (void *)out_ext;
20534             out_header = (void *)out_ext;
20535             break;
20536         }
20537         default:
20538             FIXME("Unhandled sType %u.", in_header->sType);
20539             break;
20540         }
20541     }
20542 }
20543 #endif /* USE_STRUCT_CONVERSION */
20544
20545 #if defined(USE_STRUCT_CONVERSION)
20546 static inline void convert_VkImageFormatProperties2_host_to_win32(const VkImageFormatProperties2 *in, VkImageFormatProperties232 *out)
20547 {
20548     const VkBaseInStructure *in_header;
20549     VkBaseOutStructure *out_header = (void *)out;
20550
20551     if (!in) return;
20552
20553     convert_VkImageFormatProperties_host_to_win32(&in->imageFormatProperties, &out->imageFormatProperties);
20554
20555     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
20556     {
20557         switch (in_header->sType)
20558         {
20559         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
20560         {
20561             VkExternalImageFormatProperties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
20562             const VkExternalImageFormatProperties *in_ext = (const VkExternalImageFormatProperties *)in_header;
20563             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
20564             out_ext->externalMemoryProperties = in_ext->externalMemoryProperties;
20565             out_header = (void *)out_ext;
20566             break;
20567         }
20568         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
20569         {
20570             VkSamplerYcbcrConversionImageFormatProperties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
20571             const VkSamplerYcbcrConversionImageFormatProperties *in_ext = (const VkSamplerYcbcrConversionImageFormatProperties *)in_header;
20572             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
20573             out_ext->combinedImageSamplerDescriptorCount = in_ext->combinedImageSamplerDescriptorCount;
20574             out_header = (void *)out_ext;
20575             break;
20576         }
20577         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
20578         {
20579             VkTextureLODGatherFormatPropertiesAMD32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD);
20580             const VkTextureLODGatherFormatPropertiesAMD *in_ext = (const VkTextureLODGatherFormatPropertiesAMD *)in_header;
20581             out_ext->sType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD;
20582             out_ext->supportsTextureGatherLODBiasAMD = in_ext->supportsTextureGatherLODBiasAMD;
20583             out_header = (void *)out_ext;
20584             break;
20585         }
20586         case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
20587         {
20588             VkFilterCubicImageViewImageFormatPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT);
20589             const VkFilterCubicImageViewImageFormatPropertiesEXT *in_ext = (const VkFilterCubicImageViewImageFormatPropertiesEXT *)in_header;
20590             out_ext->sType = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT;
20591             out_ext->filterCubic = in_ext->filterCubic;
20592             out_ext->filterCubicMinmax = in_ext->filterCubicMinmax;
20593             out_header = (void *)out_ext;
20594             break;
20595         }
20596         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
20597         {
20598             VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT);
20599             const VkImageCompressionPropertiesEXT *in_ext = (const VkImageCompressionPropertiesEXT *)in_header;
20600             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
20601             out_ext->imageCompressionFlags = in_ext->imageCompressionFlags;
20602             out_ext->imageCompressionFixedRateFlags = in_ext->imageCompressionFixedRateFlags;
20603             out_header = (void *)out_ext;
20604             break;
20605         }
20606         default:
20607             break;
20608         }
20609     }
20610 }
20611 #endif /* USE_STRUCT_CONVERSION */
20612
20613 #if defined(USE_STRUCT_CONVERSION)
20614 static inline void convert_VkMemoryHeap_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out)
20615 {
20616     if (!in) return;
20617
20618     out->size = in->size;
20619     out->flags = in->flags;
20620 }
20621 #endif /* USE_STRUCT_CONVERSION */
20622
20623 #if defined(USE_STRUCT_CONVERSION)
20624 static inline void convert_VkMemoryHeap_array_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out, uint32_t count)
20625 {
20626     unsigned int i;
20627
20628     if (!in) return;
20629
20630     for (i = 0; i < count; i++)
20631     {
20632         convert_VkMemoryHeap_host_to_win32(&in[i], &out[i]);
20633     }
20634 }
20635 #endif /* USE_STRUCT_CONVERSION */
20636
20637 #if defined(USE_STRUCT_CONVERSION)
20638 static inline void convert_VkPhysicalDeviceMemoryProperties_host_to_win32(const VkPhysicalDeviceMemoryProperties *in, VkPhysicalDeviceMemoryProperties32 *out)
20639 {
20640     if (!in) return;
20641
20642     out->memoryTypeCount = in->memoryTypeCount;
20643     memcpy(out->memoryTypes, in->memoryTypes, VK_MAX_MEMORY_TYPES * sizeof(VkMemoryType));
20644     out->memoryHeapCount = in->memoryHeapCount;
20645     convert_VkMemoryHeap_array_host_to_win32(in->memoryHeaps, out->memoryHeaps, VK_MAX_MEMORY_HEAPS);
20646 }
20647 #endif /* USE_STRUCT_CONVERSION */
20648
20649 #if defined(USE_STRUCT_CONVERSION)
20650 static inline void convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceMemoryProperties232 *in, VkPhysicalDeviceMemoryProperties2 *out)
20651 {
20652     const VkBaseInStructure *in_header;
20653     VkBaseOutStructure *out_header = (void *)out;
20654
20655     if (!in) return;
20656
20657     out->sType = in->sType;
20658     out->pNext = NULL;
20659
20660     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
20661     {
20662         switch (in_header->sType)
20663         {
20664         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
20665         {
20666             VkPhysicalDeviceMemoryBudgetPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20667             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
20668             out_ext->pNext = NULL;
20669             out_header->pNext = (void *)out_ext;
20670             out_header = (void *)out_ext;
20671             break;
20672         }
20673         default:
20674             FIXME("Unhandled sType %u.", in_header->sType);
20675             break;
20676         }
20677     }
20678 }
20679 #endif /* USE_STRUCT_CONVERSION */
20680
20681 #if defined(USE_STRUCT_CONVERSION)
20682 static inline void convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(const VkPhysicalDeviceMemoryProperties2 *in, VkPhysicalDeviceMemoryProperties232 *out)
20683 {
20684     const VkBaseInStructure *in_header;
20685     VkBaseOutStructure *out_header = (void *)out;
20686
20687     if (!in) return;
20688
20689     convert_VkPhysicalDeviceMemoryProperties_host_to_win32(&in->memoryProperties, &out->memoryProperties);
20690
20691     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
20692     {
20693         switch (in_header->sType)
20694         {
20695         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
20696         {
20697             VkPhysicalDeviceMemoryBudgetPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT);
20698             const VkPhysicalDeviceMemoryBudgetPropertiesEXT *in_ext = (const VkPhysicalDeviceMemoryBudgetPropertiesEXT *)in_header;
20699             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
20700             memcpy(out_ext->heapBudget, in_ext->heapBudget, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
20701             memcpy(out_ext->heapUsage, in_ext->heapUsage, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
20702             out_header = (void *)out_ext;
20703             break;
20704         }
20705         default:
20706             break;
20707         }
20708     }
20709 }
20710 #endif /* USE_STRUCT_CONVERSION */
20711
20712 #if defined(USE_STRUCT_CONVERSION)
20713 static inline void convert_VkMultisamplePropertiesEXT_win32_to_host(const VkMultisamplePropertiesEXT32 *in, VkMultisamplePropertiesEXT *out)
20714 {
20715     if (!in) return;
20716
20717     out->sType = in->sType;
20718     out->pNext = in->pNext;
20719 }
20720 #endif /* USE_STRUCT_CONVERSION */
20721
20722 #if defined(USE_STRUCT_CONVERSION)
20723 static inline void convert_VkMultisamplePropertiesEXT_host_to_win32(const VkMultisamplePropertiesEXT *in, VkMultisamplePropertiesEXT32 *out)
20724 {
20725     if (!in) return;
20726
20727     out->maxSampleLocationGridSize = in->maxSampleLocationGridSize;
20728 }
20729 #endif /* USE_STRUCT_CONVERSION */
20730
20731 #if defined(USE_STRUCT_CONVERSION)
20732 static inline void convert_VkOpticalFlowImageFormatInfoNV_win32_to_host(const VkOpticalFlowImageFormatInfoNV32 *in, VkOpticalFlowImageFormatInfoNV *out)
20733 {
20734     if (!in) return;
20735
20736     out->sType = in->sType;
20737     out->pNext = in->pNext;
20738     out->usage = in->usage;
20739 }
20740 #endif /* USE_STRUCT_CONVERSION */
20741
20742 #if defined(USE_STRUCT_CONVERSION)
20743 static inline void convert_VkOpticalFlowImageFormatPropertiesNV_win32_to_host(const VkOpticalFlowImageFormatPropertiesNV32 *in, VkOpticalFlowImageFormatPropertiesNV *out)
20744 {
20745     if (!in) return;
20746
20747     out->sType = in->sType;
20748     out->pNext = in->pNext;
20749 }
20750 #endif /* USE_STRUCT_CONVERSION */
20751
20752 #if defined(USE_STRUCT_CONVERSION)
20753 static inline void convert_VkOpticalFlowImageFormatPropertiesNV_host_to_win32(const VkOpticalFlowImageFormatPropertiesNV *in, VkOpticalFlowImageFormatPropertiesNV32 *out)
20754 {
20755     if (!in) return;
20756
20757     out->format = in->format;
20758 }
20759 #endif /* USE_STRUCT_CONVERSION */
20760
20761 #if defined(USE_STRUCT_CONVERSION)
20762 static inline VkOpticalFlowImageFormatPropertiesNV *convert_VkOpticalFlowImageFormatPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkOpticalFlowImageFormatPropertiesNV32 *in, uint32_t count)
20763 {
20764     VkOpticalFlowImageFormatPropertiesNV *out;
20765     unsigned int i;
20766
20767     if (!in || !count) return NULL;
20768
20769     out = conversion_context_alloc(ctx, count * sizeof(*out));
20770     for (i = 0; i < count; i++)
20771     {
20772         convert_VkOpticalFlowImageFormatPropertiesNV_win32_to_host(&in[i], &out[i]);
20773     }
20774
20775     return out;
20776 }
20777 #endif /* USE_STRUCT_CONVERSION */
20778
20779 #if defined(USE_STRUCT_CONVERSION)
20780 static inline void convert_VkOpticalFlowImageFormatPropertiesNV_array_host_to_win32(const VkOpticalFlowImageFormatPropertiesNV *in, VkOpticalFlowImageFormatPropertiesNV32 *out, uint32_t count)
20781 {
20782     unsigned int i;
20783
20784     if (!in) return;
20785
20786     for (i = 0; i < count; i++)
20787     {
20788         convert_VkOpticalFlowImageFormatPropertiesNV_host_to_win32(&in[i], &out[i]);
20789     }
20790 }
20791 #endif /* USE_STRUCT_CONVERSION */
20792
20793 #if defined(USE_STRUCT_CONVERSION)
20794 static inline void convert_VkPhysicalDeviceLimits_host_to_win32(const VkPhysicalDeviceLimits *in, VkPhysicalDeviceLimits32 *out)
20795 {
20796     if (!in) return;
20797
20798     out->maxImageDimension1D = in->maxImageDimension1D;
20799     out->maxImageDimension2D = in->maxImageDimension2D;
20800     out->maxImageDimension3D = in->maxImageDimension3D;
20801     out->maxImageDimensionCube = in->maxImageDimensionCube;
20802     out->maxImageArrayLayers = in->maxImageArrayLayers;
20803     out->maxTexelBufferElements = in->maxTexelBufferElements;
20804     out->maxUniformBufferRange = in->maxUniformBufferRange;
20805     out->maxStorageBufferRange = in->maxStorageBufferRange;
20806     out->maxPushConstantsSize = in->maxPushConstantsSize;
20807     out->maxMemoryAllocationCount = in->maxMemoryAllocationCount;
20808     out->maxSamplerAllocationCount = in->maxSamplerAllocationCount;
20809     out->bufferImageGranularity = in->bufferImageGranularity;
20810     out->sparseAddressSpaceSize = in->sparseAddressSpaceSize;
20811     out->maxBoundDescriptorSets = in->maxBoundDescriptorSets;
20812     out->maxPerStageDescriptorSamplers = in->maxPerStageDescriptorSamplers;
20813     out->maxPerStageDescriptorUniformBuffers = in->maxPerStageDescriptorUniformBuffers;
20814     out->maxPerStageDescriptorStorageBuffers = in->maxPerStageDescriptorStorageBuffers;
20815     out->maxPerStageDescriptorSampledImages = in->maxPerStageDescriptorSampledImages;
20816     out->maxPerStageDescriptorStorageImages = in->maxPerStageDescriptorStorageImages;
20817     out->maxPerStageDescriptorInputAttachments = in->maxPerStageDescriptorInputAttachments;
20818     out->maxPerStageResources = in->maxPerStageResources;
20819     out->maxDescriptorSetSamplers = in->maxDescriptorSetSamplers;
20820     out->maxDescriptorSetUniformBuffers = in->maxDescriptorSetUniformBuffers;
20821     out->maxDescriptorSetUniformBuffersDynamic = in->maxDescriptorSetUniformBuffersDynamic;
20822     out->maxDescriptorSetStorageBuffers = in->maxDescriptorSetStorageBuffers;
20823     out->maxDescriptorSetStorageBuffersDynamic = in->maxDescriptorSetStorageBuffersDynamic;
20824     out->maxDescriptorSetSampledImages = in->maxDescriptorSetSampledImages;
20825     out->maxDescriptorSetStorageImages = in->maxDescriptorSetStorageImages;
20826     out->maxDescriptorSetInputAttachments = in->maxDescriptorSetInputAttachments;
20827     out->maxVertexInputAttributes = in->maxVertexInputAttributes;
20828     out->maxVertexInputBindings = in->maxVertexInputBindings;
20829     out->maxVertexInputAttributeOffset = in->maxVertexInputAttributeOffset;
20830     out->maxVertexInputBindingStride = in->maxVertexInputBindingStride;
20831     out->maxVertexOutputComponents = in->maxVertexOutputComponents;
20832     out->maxTessellationGenerationLevel = in->maxTessellationGenerationLevel;
20833     out->maxTessellationPatchSize = in->maxTessellationPatchSize;
20834     out->maxTessellationControlPerVertexInputComponents = in->maxTessellationControlPerVertexInputComponents;
20835     out->maxTessellationControlPerVertexOutputComponents = in->maxTessellationControlPerVertexOutputComponents;
20836     out->maxTessellationControlPerPatchOutputComponents = in->maxTessellationControlPerPatchOutputComponents;
20837     out->maxTessellationControlTotalOutputComponents = in->maxTessellationControlTotalOutputComponents;
20838     out->maxTessellationEvaluationInputComponents = in->maxTessellationEvaluationInputComponents;
20839     out->maxTessellationEvaluationOutputComponents = in->maxTessellationEvaluationOutputComponents;
20840     out->maxGeometryShaderInvocations = in->maxGeometryShaderInvocations;
20841     out->maxGeometryInputComponents = in->maxGeometryInputComponents;
20842     out->maxGeometryOutputComponents = in->maxGeometryOutputComponents;
20843     out->maxGeometryOutputVertices = in->maxGeometryOutputVertices;
20844     out->maxGeometryTotalOutputComponents = in->maxGeometryTotalOutputComponents;
20845     out->maxFragmentInputComponents = in->maxFragmentInputComponents;
20846     out->maxFragmentOutputAttachments = in->maxFragmentOutputAttachments;
20847     out->maxFragmentDualSrcAttachments = in->maxFragmentDualSrcAttachments;
20848     out->maxFragmentCombinedOutputResources = in->maxFragmentCombinedOutputResources;
20849     out->maxComputeSharedMemorySize = in->maxComputeSharedMemorySize;
20850     memcpy(out->maxComputeWorkGroupCount, in->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
20851     out->maxComputeWorkGroupInvocations = in->maxComputeWorkGroupInvocations;
20852     memcpy(out->maxComputeWorkGroupSize, in->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
20853     out->subPixelPrecisionBits = in->subPixelPrecisionBits;
20854     out->subTexelPrecisionBits = in->subTexelPrecisionBits;
20855     out->mipmapPrecisionBits = in->mipmapPrecisionBits;
20856     out->maxDrawIndexedIndexValue = in->maxDrawIndexedIndexValue;
20857     out->maxDrawIndirectCount = in->maxDrawIndirectCount;
20858     out->maxSamplerLodBias = in->maxSamplerLodBias;
20859     out->maxSamplerAnisotropy = in->maxSamplerAnisotropy;
20860     out->maxViewports = in->maxViewports;
20861     memcpy(out->maxViewportDimensions, in->maxViewportDimensions, 2 * sizeof(uint32_t));
20862     memcpy(out->viewportBoundsRange, in->viewportBoundsRange, 2 * sizeof(float));
20863     out->viewportSubPixelBits = in->viewportSubPixelBits;
20864     out->minMemoryMapAlignment = in->minMemoryMapAlignment;
20865     out->minTexelBufferOffsetAlignment = in->minTexelBufferOffsetAlignment;
20866     out->minUniformBufferOffsetAlignment = in->minUniformBufferOffsetAlignment;
20867     out->minStorageBufferOffsetAlignment = in->minStorageBufferOffsetAlignment;
20868     out->minTexelOffset = in->minTexelOffset;
20869     out->maxTexelOffset = in->maxTexelOffset;
20870     out->minTexelGatherOffset = in->minTexelGatherOffset;
20871     out->maxTexelGatherOffset = in->maxTexelGatherOffset;
20872     out->minInterpolationOffset = in->minInterpolationOffset;
20873     out->maxInterpolationOffset = in->maxInterpolationOffset;
20874     out->subPixelInterpolationOffsetBits = in->subPixelInterpolationOffsetBits;
20875     out->maxFramebufferWidth = in->maxFramebufferWidth;
20876     out->maxFramebufferHeight = in->maxFramebufferHeight;
20877     out->maxFramebufferLayers = in->maxFramebufferLayers;
20878     out->framebufferColorSampleCounts = in->framebufferColorSampleCounts;
20879     out->framebufferDepthSampleCounts = in->framebufferDepthSampleCounts;
20880     out->framebufferStencilSampleCounts = in->framebufferStencilSampleCounts;
20881     out->framebufferNoAttachmentsSampleCounts = in->framebufferNoAttachmentsSampleCounts;
20882     out->maxColorAttachments = in->maxColorAttachments;
20883     out->sampledImageColorSampleCounts = in->sampledImageColorSampleCounts;
20884     out->sampledImageIntegerSampleCounts = in->sampledImageIntegerSampleCounts;
20885     out->sampledImageDepthSampleCounts = in->sampledImageDepthSampleCounts;
20886     out->sampledImageStencilSampleCounts = in->sampledImageStencilSampleCounts;
20887     out->storageImageSampleCounts = in->storageImageSampleCounts;
20888     out->maxSampleMaskWords = in->maxSampleMaskWords;
20889     out->timestampComputeAndGraphics = in->timestampComputeAndGraphics;
20890     out->timestampPeriod = in->timestampPeriod;
20891     out->maxClipDistances = in->maxClipDistances;
20892     out->maxCullDistances = in->maxCullDistances;
20893     out->maxCombinedClipAndCullDistances = in->maxCombinedClipAndCullDistances;
20894     out->discreteQueuePriorities = in->discreteQueuePriorities;
20895     memcpy(out->pointSizeRange, in->pointSizeRange, 2 * sizeof(float));
20896     memcpy(out->lineWidthRange, in->lineWidthRange, 2 * sizeof(float));
20897     out->pointSizeGranularity = in->pointSizeGranularity;
20898     out->lineWidthGranularity = in->lineWidthGranularity;
20899     out->strictLines = in->strictLines;
20900     out->standardSampleLocations = in->standardSampleLocations;
20901     out->optimalBufferCopyOffsetAlignment = in->optimalBufferCopyOffsetAlignment;
20902     out->optimalBufferCopyRowPitchAlignment = in->optimalBufferCopyRowPitchAlignment;
20903     out->nonCoherentAtomSize = in->nonCoherentAtomSize;
20904 }
20905 #endif /* USE_STRUCT_CONVERSION */
20906
20907 #if defined(USE_STRUCT_CONVERSION)
20908 static inline void convert_VkPhysicalDeviceProperties_host_to_win32(const VkPhysicalDeviceProperties *in, VkPhysicalDeviceProperties32 *out)
20909 {
20910     if (!in) return;
20911
20912     out->apiVersion = in->apiVersion;
20913     out->driverVersion = in->driverVersion;
20914     out->vendorID = in->vendorID;
20915     out->deviceID = in->deviceID;
20916     out->deviceType = in->deviceType;
20917     memcpy(out->deviceName, in->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
20918     memcpy(out->pipelineCacheUUID, in->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
20919     convert_VkPhysicalDeviceLimits_host_to_win32(&in->limits, &out->limits);
20920     out->sparseProperties = in->sparseProperties;
20921 }
20922 #endif /* USE_STRUCT_CONVERSION */
20923
20924 #if defined(USE_STRUCT_CONVERSION)
20925 static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceProperties232 *in, VkPhysicalDeviceProperties2 *out)
20926 {
20927     const VkBaseInStructure *in_header;
20928     VkBaseOutStructure *out_header = (void *)out;
20929
20930     if (!in) return;
20931
20932     out->sType = in->sType;
20933     out->pNext = NULL;
20934
20935     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
20936     {
20937         switch (in_header->sType)
20938         {
20939         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
20940         {
20941             VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20942             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV;
20943             out_ext->pNext = NULL;
20944             out_header->pNext = (void *)out_ext;
20945             out_header = (void *)out_ext;
20946             break;
20947         }
20948         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
20949         {
20950             VkPhysicalDeviceMultiDrawPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20951             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
20952             out_ext->pNext = NULL;
20953             out_header->pNext = (void *)out_ext;
20954             out_header = (void *)out_ext;
20955             break;
20956         }
20957         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
20958         {
20959             VkPhysicalDevicePushDescriptorPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20960             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
20961             out_ext->pNext = NULL;
20962             out_header->pNext = (void *)out_ext;
20963             out_header = (void *)out_ext;
20964             break;
20965         }
20966         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
20967         {
20968             VkPhysicalDeviceDriverProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20969             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
20970             out_ext->pNext = NULL;
20971             out_header->pNext = (void *)out_ext;
20972             out_header = (void *)out_ext;
20973             break;
20974         }
20975         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
20976         {
20977             VkPhysicalDeviceIDProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20978             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
20979             out_ext->pNext = NULL;
20980             out_header->pNext = (void *)out_ext;
20981             out_header = (void *)out_ext;
20982             break;
20983         }
20984         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
20985         {
20986             VkPhysicalDeviceMultiviewProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20987             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
20988             out_ext->pNext = NULL;
20989             out_header->pNext = (void *)out_ext;
20990             out_header = (void *)out_ext;
20991             break;
20992         }
20993         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
20994         {
20995             VkPhysicalDeviceDiscardRectanglePropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20996             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
20997             out_ext->pNext = NULL;
20998             out_header->pNext = (void *)out_ext;
20999             out_header = (void *)out_ext;
21000             break;
21001         }
21002         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
21003         {
21004             VkPhysicalDeviceSubgroupProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21005             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
21006             out_ext->pNext = NULL;
21007             out_header->pNext = (void *)out_ext;
21008             out_header = (void *)out_ext;
21009             break;
21010         }
21011         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
21012         {
21013             VkPhysicalDevicePointClippingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21014             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
21015             out_ext->pNext = NULL;
21016             out_header->pNext = (void *)out_ext;
21017             out_header = (void *)out_ext;
21018             break;
21019         }
21020         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
21021         {
21022             VkPhysicalDeviceProtectedMemoryProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21023             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
21024             out_ext->pNext = NULL;
21025             out_header->pNext = (void *)out_ext;
21026             out_header = (void *)out_ext;
21027             break;
21028         }
21029         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
21030         {
21031             VkPhysicalDeviceSamplerFilterMinmaxProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21032             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
21033             out_ext->pNext = NULL;
21034             out_header->pNext = (void *)out_ext;
21035             out_header = (void *)out_ext;
21036             break;
21037         }
21038         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
21039         {
21040             VkPhysicalDeviceSampleLocationsPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21041             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
21042             out_ext->pNext = NULL;
21043             out_header->pNext = (void *)out_ext;
21044             out_header = (void *)out_ext;
21045             break;
21046         }
21047         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
21048         {
21049             VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21050             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
21051             out_ext->pNext = NULL;
21052             out_header->pNext = (void *)out_ext;
21053             out_header = (void *)out_ext;
21054             break;
21055         }
21056         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
21057         {
21058             VkPhysicalDeviceInlineUniformBlockProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21059             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
21060             out_ext->pNext = NULL;
21061             out_header->pNext = (void *)out_ext;
21062             out_header = (void *)out_ext;
21063             break;
21064         }
21065         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
21066         {
21067             VkPhysicalDeviceMaintenance3Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21068             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
21069             out_ext->pNext = NULL;
21070             out_header->pNext = (void *)out_ext;
21071             out_header = (void *)out_ext;
21072             break;
21073         }
21074         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
21075         {
21076             VkPhysicalDeviceMaintenance4Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21077             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
21078             out_ext->pNext = NULL;
21079             out_header->pNext = (void *)out_ext;
21080             out_header = (void *)out_ext;
21081             break;
21082         }
21083         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
21084         {
21085             VkPhysicalDeviceFloatControlsProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21086             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
21087             out_ext->pNext = NULL;
21088             out_header->pNext = (void *)out_ext;
21089             out_header = (void *)out_ext;
21090             break;
21091         }
21092         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
21093         {
21094             VkPhysicalDeviceExternalMemoryHostPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21095             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
21096             out_ext->pNext = NULL;
21097             out_header->pNext = (void *)out_ext;
21098             out_header = (void *)out_ext;
21099             break;
21100         }
21101         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
21102         {
21103             VkPhysicalDeviceConservativeRasterizationPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21104             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
21105             out_ext->pNext = NULL;
21106             out_header->pNext = (void *)out_ext;
21107             out_header = (void *)out_ext;
21108             break;
21109         }
21110         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
21111         {
21112             VkPhysicalDeviceShaderCorePropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21113             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;
21114             out_ext->pNext = NULL;
21115             out_header->pNext = (void *)out_ext;
21116             out_header = (void *)out_ext;
21117             break;
21118         }
21119         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
21120         {
21121             VkPhysicalDeviceShaderCoreProperties2AMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21122             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
21123             out_ext->pNext = NULL;
21124             out_header->pNext = (void *)out_ext;
21125             out_header = (void *)out_ext;
21126             break;
21127         }
21128         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
21129         {
21130             VkPhysicalDeviceDescriptorIndexingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21131             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
21132             out_ext->pNext = NULL;
21133             out_header->pNext = (void *)out_ext;
21134             out_header = (void *)out_ext;
21135             break;
21136         }
21137         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
21138         {
21139             VkPhysicalDeviceTimelineSemaphoreProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21140             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
21141             out_ext->pNext = NULL;
21142             out_header->pNext = (void *)out_ext;
21143             out_header = (void *)out_ext;
21144             break;
21145         }
21146         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
21147         {
21148             VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21149             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
21150             out_ext->pNext = NULL;
21151             out_header->pNext = (void *)out_ext;
21152             out_header = (void *)out_ext;
21153             break;
21154         }
21155         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
21156         {
21157             VkPhysicalDevicePCIBusInfoPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21158             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
21159             out_ext->pNext = NULL;
21160             out_header->pNext = (void *)out_ext;
21161             out_header = (void *)out_ext;
21162             break;
21163         }
21164         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
21165         {
21166             VkPhysicalDeviceDepthStencilResolveProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21167             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
21168             out_ext->pNext = NULL;
21169             out_header->pNext = (void *)out_ext;
21170             out_header = (void *)out_ext;
21171             break;
21172         }
21173         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
21174         {
21175             VkPhysicalDeviceTransformFeedbackPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21176             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
21177             out_ext->pNext = NULL;
21178             out_header->pNext = (void *)out_ext;
21179             out_header = (void *)out_ext;
21180             break;
21181         }
21182         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
21183         {
21184             VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21185             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
21186             out_ext->pNext = NULL;
21187             out_header->pNext = (void *)out_ext;
21188             out_header = (void *)out_ext;
21189             break;
21190         }
21191         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
21192         {
21193             VkPhysicalDeviceMemoryDecompressionPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21194             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV;
21195             out_ext->pNext = NULL;
21196             out_header->pNext = (void *)out_ext;
21197             out_header = (void *)out_ext;
21198             break;
21199         }
21200         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
21201         {
21202             VkPhysicalDeviceShadingRateImagePropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21203             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV;
21204             out_ext->pNext = NULL;
21205             out_header->pNext = (void *)out_ext;
21206             out_header = (void *)out_ext;
21207             break;
21208         }
21209         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
21210         {
21211             VkPhysicalDeviceMeshShaderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21212             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV;
21213             out_ext->pNext = NULL;
21214             out_header->pNext = (void *)out_ext;
21215             out_header = (void *)out_ext;
21216             break;
21217         }
21218         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
21219         {
21220             VkPhysicalDeviceMeshShaderPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21221             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
21222             out_ext->pNext = NULL;
21223             out_header->pNext = (void *)out_ext;
21224             out_header = (void *)out_ext;
21225             break;
21226         }
21227         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
21228         {
21229             VkPhysicalDeviceAccelerationStructurePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21230             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
21231             out_ext->pNext = NULL;
21232             out_header->pNext = (void *)out_ext;
21233             out_header = (void *)out_ext;
21234             break;
21235         }
21236         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
21237         {
21238             VkPhysicalDeviceRayTracingPipelinePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21239             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
21240             out_ext->pNext = NULL;
21241             out_header->pNext = (void *)out_ext;
21242             out_header = (void *)out_ext;
21243             break;
21244         }
21245         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
21246         {
21247             VkPhysicalDeviceRayTracingPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21248             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
21249             out_ext->pNext = NULL;
21250             out_header->pNext = (void *)out_ext;
21251             out_header = (void *)out_ext;
21252             break;
21253         }
21254         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
21255         {
21256             VkPhysicalDeviceFragmentDensityMapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21257             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
21258             out_ext->pNext = NULL;
21259             out_header->pNext = (void *)out_ext;
21260             out_header = (void *)out_ext;
21261             break;
21262         }
21263         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
21264         {
21265             VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21266             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
21267             out_ext->pNext = NULL;
21268             out_header->pNext = (void *)out_ext;
21269             out_header = (void *)out_ext;
21270             break;
21271         }
21272         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
21273         {
21274             VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21275             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM;
21276             out_ext->pNext = NULL;
21277             out_header->pNext = (void *)out_ext;
21278             out_header = (void *)out_ext;
21279             break;
21280         }
21281         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
21282         {
21283             VkPhysicalDeviceCooperativeMatrixPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21284             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV;
21285             out_ext->pNext = NULL;
21286             out_header->pNext = (void *)out_ext;
21287             out_header = (void *)out_ext;
21288             break;
21289         }
21290         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
21291         {
21292             VkPhysicalDevicePerformanceQueryPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21293             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
21294             out_ext->pNext = NULL;
21295             out_header->pNext = (void *)out_ext;
21296             out_header = (void *)out_ext;
21297             break;
21298         }
21299         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
21300         {
21301             VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21302             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
21303             out_ext->pNext = NULL;
21304             out_header->pNext = (void *)out_ext;
21305             out_header = (void *)out_ext;
21306             break;
21307         }
21308         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
21309         {
21310             VkPhysicalDeviceTexelBufferAlignmentProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21311             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
21312             out_ext->pNext = NULL;
21313             out_header->pNext = (void *)out_ext;
21314             out_header = (void *)out_ext;
21315             break;
21316         }
21317         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
21318         {
21319             VkPhysicalDeviceSubgroupSizeControlProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21320             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
21321             out_ext->pNext = NULL;
21322             out_header->pNext = (void *)out_ext;
21323             out_header = (void *)out_ext;
21324             break;
21325         }
21326         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
21327         {
21328             VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21329             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI;
21330             out_ext->pNext = NULL;
21331             out_header->pNext = (void *)out_ext;
21332             out_header = (void *)out_ext;
21333             break;
21334         }
21335         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
21336         {
21337             VkPhysicalDeviceLineRasterizationPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21338             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT;
21339             out_ext->pNext = NULL;
21340             out_header->pNext = (void *)out_ext;
21341             out_header = (void *)out_ext;
21342             break;
21343         }
21344         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
21345         {
21346             VkPhysicalDeviceVulkan11Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21347             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
21348             out_ext->pNext = NULL;
21349             out_header->pNext = (void *)out_ext;
21350             out_header = (void *)out_ext;
21351             break;
21352         }
21353         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
21354         {
21355             VkPhysicalDeviceVulkan12Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21356             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
21357             out_ext->pNext = NULL;
21358             out_header->pNext = (void *)out_ext;
21359             out_header = (void *)out_ext;
21360             break;
21361         }
21362         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
21363         {
21364             VkPhysicalDeviceVulkan13Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21365             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
21366             out_ext->pNext = NULL;
21367             out_header->pNext = (void *)out_ext;
21368             out_header = (void *)out_ext;
21369             break;
21370         }
21371         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
21372         {
21373             VkPhysicalDeviceCustomBorderColorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21374             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
21375             out_ext->pNext = NULL;
21376             out_header->pNext = (void *)out_ext;
21377             out_header = (void *)out_ext;
21378             break;
21379         }
21380         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
21381         {
21382             VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21383             const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 *)in_header;
21384             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
21385             out_ext->pNext = NULL;
21386             out_ext->dynamicPrimitiveTopologyUnrestricted = in_ext->dynamicPrimitiveTopologyUnrestricted;
21387             out_header->pNext = (void *)out_ext;
21388             out_header = (void *)out_ext;
21389             break;
21390         }
21391         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
21392         {
21393             VkPhysicalDeviceRobustness2PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21394             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT;
21395             out_ext->pNext = NULL;
21396             out_header->pNext = (void *)out_ext;
21397             out_header = (void *)out_ext;
21398             break;
21399         }
21400         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
21401         {
21402             VkPhysicalDeviceFragmentShadingRatePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21403             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
21404             out_ext->pNext = NULL;
21405             out_header->pNext = (void *)out_ext;
21406             out_header = (void *)out_ext;
21407             break;
21408         }
21409         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
21410         {
21411             VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21412             const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 *)in_header;
21413             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV;
21414             out_ext->pNext = NULL;
21415             out_ext->maxFragmentShadingRateInvocationCount = in_ext->maxFragmentShadingRateInvocationCount;
21416             out_header->pNext = (void *)out_ext;
21417             out_header = (void *)out_ext;
21418             break;
21419         }
21420         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
21421         {
21422             VkPhysicalDeviceProvokingVertexPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21423             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
21424             out_ext->pNext = NULL;
21425             out_header->pNext = (void *)out_ext;
21426             out_header = (void *)out_ext;
21427             break;
21428         }
21429         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
21430         {
21431             VkPhysicalDeviceShaderIntegerDotProductProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21432             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
21433             out_ext->pNext = NULL;
21434             out_header->pNext = (void *)out_ext;
21435             out_header = (void *)out_ext;
21436             break;
21437         }
21438         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
21439         {
21440             VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21441             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
21442             out_ext->pNext = NULL;
21443             out_header->pNext = (void *)out_ext;
21444             out_header = (void *)out_ext;
21445             break;
21446         }
21447         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
21448         {
21449             VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21450             const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *)in_header;
21451             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
21452             out_ext->pNext = NULL;
21453             out_ext->graphicsPipelineLibraryFastLinking = in_ext->graphicsPipelineLibraryFastLinking;
21454             out_ext->graphicsPipelineLibraryIndependentInterpolationDecoration = in_ext->graphicsPipelineLibraryIndependentInterpolationDecoration;
21455             out_header->pNext = (void *)out_ext;
21456             out_header = (void *)out_ext;
21457             break;
21458         }
21459         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
21460         {
21461             VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21462             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
21463             out_ext->pNext = NULL;
21464             out_header->pNext = (void *)out_ext;
21465             out_header = (void *)out_ext;
21466             break;
21467         }
21468         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
21469         {
21470             VkPhysicalDeviceOpacityMicromapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21471             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
21472             out_ext->pNext = NULL;
21473             out_header->pNext = (void *)out_ext;
21474             out_header = (void *)out_ext;
21475             break;
21476         }
21477         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
21478         {
21479             VkPhysicalDevicePipelineRobustnessPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21480             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT;
21481             out_ext->pNext = NULL;
21482             out_header->pNext = (void *)out_ext;
21483             out_header = (void *)out_ext;
21484             break;
21485         }
21486         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
21487         {
21488             VkPhysicalDeviceImageProcessingPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21489             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM;
21490             out_ext->pNext = NULL;
21491             out_header->pNext = (void *)out_ext;
21492             out_header = (void *)out_ext;
21493             break;
21494         }
21495         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
21496         {
21497             VkPhysicalDeviceOpticalFlowPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21498             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV;
21499             out_ext->pNext = NULL;
21500             out_header->pNext = (void *)out_ext;
21501             out_header = (void *)out_ext;
21502             break;
21503         }
21504         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
21505         {
21506             VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21507             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM;
21508             out_ext->pNext = NULL;
21509             out_header->pNext = (void *)out_ext;
21510             out_header = (void *)out_ext;
21511             break;
21512         }
21513         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
21514         {
21515             VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21516             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV;
21517             out_ext->pNext = NULL;
21518             out_header->pNext = (void *)out_ext;
21519             out_header = (void *)out_ext;
21520             break;
21521         }
21522         default:
21523             FIXME("Unhandled sType %u.", in_header->sType);
21524             break;
21525         }
21526     }
21527 }
21528 #endif /* USE_STRUCT_CONVERSION */
21529
21530 #if defined(USE_STRUCT_CONVERSION)
21531 static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDeviceProperties2 *in, VkPhysicalDeviceProperties232 *out)
21532 {
21533     const VkBaseInStructure *in_header;
21534     VkBaseOutStructure *out_header = (void *)out;
21535
21536     if (!in) return;
21537
21538     convert_VkPhysicalDeviceProperties_host_to_win32(&in->properties, &out->properties);
21539
21540     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
21541     {
21542         switch (in_header->sType)
21543         {
21544         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
21545         {
21546             VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV);
21547             const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *)in_header;
21548             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV;
21549             out_ext->maxGraphicsShaderGroupCount = in_ext->maxGraphicsShaderGroupCount;
21550             out_ext->maxIndirectSequenceCount = in_ext->maxIndirectSequenceCount;
21551             out_ext->maxIndirectCommandsTokenCount = in_ext->maxIndirectCommandsTokenCount;
21552             out_ext->maxIndirectCommandsStreamCount = in_ext->maxIndirectCommandsStreamCount;
21553             out_ext->maxIndirectCommandsTokenOffset = in_ext->maxIndirectCommandsTokenOffset;
21554             out_ext->maxIndirectCommandsStreamStride = in_ext->maxIndirectCommandsStreamStride;
21555             out_ext->minSequencesCountBufferOffsetAlignment = in_ext->minSequencesCountBufferOffsetAlignment;
21556             out_ext->minSequencesIndexBufferOffsetAlignment = in_ext->minSequencesIndexBufferOffsetAlignment;
21557             out_ext->minIndirectCommandsBufferOffsetAlignment = in_ext->minIndirectCommandsBufferOffsetAlignment;
21558             out_header = (void *)out_ext;
21559             break;
21560         }
21561         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
21562         {
21563             VkPhysicalDeviceMultiDrawPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT);
21564             const VkPhysicalDeviceMultiDrawPropertiesEXT *in_ext = (const VkPhysicalDeviceMultiDrawPropertiesEXT *)in_header;
21565             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
21566             out_ext->maxMultiDrawCount = in_ext->maxMultiDrawCount;
21567             out_header = (void *)out_ext;
21568             break;
21569         }
21570         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
21571         {
21572             VkPhysicalDevicePushDescriptorPropertiesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR);
21573             const VkPhysicalDevicePushDescriptorPropertiesKHR *in_ext = (const VkPhysicalDevicePushDescriptorPropertiesKHR *)in_header;
21574             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
21575             out_ext->maxPushDescriptors = in_ext->maxPushDescriptors;
21576             out_header = (void *)out_ext;
21577             break;
21578         }
21579         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
21580         {
21581             VkPhysicalDeviceDriverProperties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
21582             const VkPhysicalDeviceDriverProperties *in_ext = (const VkPhysicalDeviceDriverProperties *)in_header;
21583             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
21584             out_ext->driverID = in_ext->driverID;
21585             memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
21586             memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
21587             out_ext->conformanceVersion = in_ext->conformanceVersion;
21588             out_header = (void *)out_ext;
21589             break;
21590         }
21591         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
21592         {
21593             VkPhysicalDeviceIDProperties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
21594             const VkPhysicalDeviceIDProperties *in_ext = (const VkPhysicalDeviceIDProperties *)in_header;
21595             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
21596             memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
21597             memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
21598             memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
21599             out_ext->deviceNodeMask = in_ext->deviceNodeMask;
21600             out_ext->deviceLUIDValid = in_ext->deviceLUIDValid;
21601             out_header = (void *)out_ext;
21602             break;
21603         }
21604         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
21605         {
21606             VkPhysicalDeviceMultiviewProperties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
21607             const VkPhysicalDeviceMultiviewProperties *in_ext = (const VkPhysicalDeviceMultiviewProperties *)in_header;
21608             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
21609             out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount;
21610             out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex;
21611             out_header = (void *)out_ext;
21612             break;
21613         }
21614         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
21615         {
21616             VkPhysicalDeviceDiscardRectanglePropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT);
21617             const VkPhysicalDeviceDiscardRectanglePropertiesEXT *in_ext = (const VkPhysicalDeviceDiscardRectanglePropertiesEXT *)in_header;
21618             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
21619             out_ext->maxDiscardRectangles = in_ext->maxDiscardRectangles;
21620             out_header = (void *)out_ext;
21621             break;
21622         }
21623         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
21624         {
21625             VkPhysicalDeviceSubgroupProperties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
21626             const VkPhysicalDeviceSubgroupProperties *in_ext = (const VkPhysicalDeviceSubgroupProperties *)in_header;
21627             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
21628             out_ext->subgroupSize = in_ext->subgroupSize;
21629             out_ext->supportedStages = in_ext->supportedStages;
21630             out_ext->supportedOperations = in_ext->supportedOperations;
21631             out_ext->quadOperationsInAllStages = in_ext->quadOperationsInAllStages;
21632             out_header = (void *)out_ext;
21633             break;
21634         }
21635         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
21636         {
21637             VkPhysicalDevicePointClippingProperties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
21638             const VkPhysicalDevicePointClippingProperties *in_ext = (const VkPhysicalDevicePointClippingProperties *)in_header;
21639             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
21640             out_ext->pointClippingBehavior = in_ext->pointClippingBehavior;
21641             out_header = (void *)out_ext;
21642             break;
21643         }
21644         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
21645         {
21646             VkPhysicalDeviceProtectedMemoryProperties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
21647             const VkPhysicalDeviceProtectedMemoryProperties *in_ext = (const VkPhysicalDeviceProtectedMemoryProperties *)in_header;
21648             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
21649             out_ext->protectedNoFault = in_ext->protectedNoFault;
21650             out_header = (void *)out_ext;
21651             break;
21652         }
21653         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
21654         {
21655             VkPhysicalDeviceSamplerFilterMinmaxProperties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
21656             const VkPhysicalDeviceSamplerFilterMinmaxProperties *in_ext = (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)in_header;
21657             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
21658             out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats;
21659             out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping;
21660             out_header = (void *)out_ext;
21661             break;
21662         }
21663         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
21664         {
21665             VkPhysicalDeviceSampleLocationsPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT);
21666             const VkPhysicalDeviceSampleLocationsPropertiesEXT *in_ext = (const VkPhysicalDeviceSampleLocationsPropertiesEXT *)in_header;
21667             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
21668             out_ext->sampleLocationSampleCounts = in_ext->sampleLocationSampleCounts;
21669             out_ext->maxSampleLocationGridSize = in_ext->maxSampleLocationGridSize;
21670             memcpy(out_ext->sampleLocationCoordinateRange, in_ext->sampleLocationCoordinateRange, 2 * sizeof(float));
21671             out_ext->sampleLocationSubPixelBits = in_ext->sampleLocationSubPixelBits;
21672             out_ext->variableSampleLocations = in_ext->variableSampleLocations;
21673             out_header = (void *)out_ext;
21674             break;
21675         }
21676         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
21677         {
21678             VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT);
21679             const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *)in_header;
21680             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
21681             out_ext->advancedBlendMaxColorAttachments = in_ext->advancedBlendMaxColorAttachments;
21682             out_ext->advancedBlendIndependentBlend = in_ext->advancedBlendIndependentBlend;
21683             out_ext->advancedBlendNonPremultipliedSrcColor = in_ext->advancedBlendNonPremultipliedSrcColor;
21684             out_ext->advancedBlendNonPremultipliedDstColor = in_ext->advancedBlendNonPremultipliedDstColor;
21685             out_ext->advancedBlendCorrelatedOverlap = in_ext->advancedBlendCorrelatedOverlap;
21686             out_ext->advancedBlendAllOperations = in_ext->advancedBlendAllOperations;
21687             out_header = (void *)out_ext;
21688             break;
21689         }
21690         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
21691         {
21692             VkPhysicalDeviceInlineUniformBlockProperties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES);
21693             const VkPhysicalDeviceInlineUniformBlockProperties *in_ext = (const VkPhysicalDeviceInlineUniformBlockProperties *)in_header;
21694             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
21695             out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize;
21696             out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks;
21697             out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
21698             out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks;
21699             out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
21700             out_header = (void *)out_ext;
21701             break;
21702         }
21703         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
21704         {
21705             VkPhysicalDeviceMaintenance3Properties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
21706             const VkPhysicalDeviceMaintenance3Properties *in_ext = (const VkPhysicalDeviceMaintenance3Properties *)in_header;
21707             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
21708             out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors;
21709             out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize;
21710             out_header = (void *)out_ext;
21711             break;
21712         }
21713         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
21714         {
21715             VkPhysicalDeviceMaintenance4Properties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES);
21716             const VkPhysicalDeviceMaintenance4Properties *in_ext = (const VkPhysicalDeviceMaintenance4Properties *)in_header;
21717             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
21718             out_ext->maxBufferSize = in_ext->maxBufferSize;
21719             out_header = (void *)out_ext;
21720             break;
21721         }
21722         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
21723         {
21724             VkPhysicalDeviceFloatControlsProperties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
21725             const VkPhysicalDeviceFloatControlsProperties *in_ext = (const VkPhysicalDeviceFloatControlsProperties *)in_header;
21726             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
21727             out_ext->denormBehaviorIndependence = in_ext->denormBehaviorIndependence;
21728             out_ext->roundingModeIndependence = in_ext->roundingModeIndependence;
21729             out_ext->shaderSignedZeroInfNanPreserveFloat16 = in_ext->shaderSignedZeroInfNanPreserveFloat16;
21730             out_ext->shaderSignedZeroInfNanPreserveFloat32 = in_ext->shaderSignedZeroInfNanPreserveFloat32;
21731             out_ext->shaderSignedZeroInfNanPreserveFloat64 = in_ext->shaderSignedZeroInfNanPreserveFloat64;
21732             out_ext->shaderDenormPreserveFloat16 = in_ext->shaderDenormPreserveFloat16;
21733             out_ext->shaderDenormPreserveFloat32 = in_ext->shaderDenormPreserveFloat32;
21734             out_ext->shaderDenormPreserveFloat64 = in_ext->shaderDenormPreserveFloat64;
21735             out_ext->shaderDenormFlushToZeroFloat16 = in_ext->shaderDenormFlushToZeroFloat16;
21736             out_ext->shaderDenormFlushToZeroFloat32 = in_ext->shaderDenormFlushToZeroFloat32;
21737             out_ext->shaderDenormFlushToZeroFloat64 = in_ext->shaderDenormFlushToZeroFloat64;
21738             out_ext->shaderRoundingModeRTEFloat16 = in_ext->shaderRoundingModeRTEFloat16;
21739             out_ext->shaderRoundingModeRTEFloat32 = in_ext->shaderRoundingModeRTEFloat32;
21740             out_ext->shaderRoundingModeRTEFloat64 = in_ext->shaderRoundingModeRTEFloat64;
21741             out_ext->shaderRoundingModeRTZFloat16 = in_ext->shaderRoundingModeRTZFloat16;
21742             out_ext->shaderRoundingModeRTZFloat32 = in_ext->shaderRoundingModeRTZFloat32;
21743             out_ext->shaderRoundingModeRTZFloat64 = in_ext->shaderRoundingModeRTZFloat64;
21744             out_header = (void *)out_ext;
21745             break;
21746         }
21747         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
21748         {
21749             VkPhysicalDeviceExternalMemoryHostPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT);
21750             const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *in_ext = (const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *)in_header;
21751             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
21752             out_ext->minImportedHostPointerAlignment = in_ext->minImportedHostPointerAlignment;
21753             out_header = (void *)out_ext;
21754             break;
21755         }
21756         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
21757         {
21758             VkPhysicalDeviceConservativeRasterizationPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT);
21759             const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *in_ext = (const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)in_header;
21760             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
21761             out_ext->primitiveOverestimationSize = in_ext->primitiveOverestimationSize;
21762             out_ext->maxExtraPrimitiveOverestimationSize = in_ext->maxExtraPrimitiveOverestimationSize;
21763             out_ext->extraPrimitiveOverestimationSizeGranularity = in_ext->extraPrimitiveOverestimationSizeGranularity;
21764             out_ext->primitiveUnderestimation = in_ext->primitiveUnderestimation;
21765             out_ext->conservativePointAndLineRasterization = in_ext->conservativePointAndLineRasterization;
21766             out_ext->degenerateTrianglesRasterized = in_ext->degenerateTrianglesRasterized;
21767             out_ext->degenerateLinesRasterized = in_ext->degenerateLinesRasterized;
21768             out_ext->fullyCoveredFragmentShaderInputVariable = in_ext->fullyCoveredFragmentShaderInputVariable;
21769             out_ext->conservativeRasterizationPostDepthCoverage = in_ext->conservativeRasterizationPostDepthCoverage;
21770             out_header = (void *)out_ext;
21771             break;
21772         }
21773         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
21774         {
21775             VkPhysicalDeviceShaderCorePropertiesAMD32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD);
21776             const VkPhysicalDeviceShaderCorePropertiesAMD *in_ext = (const VkPhysicalDeviceShaderCorePropertiesAMD *)in_header;
21777             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;
21778             out_ext->shaderEngineCount = in_ext->shaderEngineCount;
21779             out_ext->shaderArraysPerEngineCount = in_ext->shaderArraysPerEngineCount;
21780             out_ext->computeUnitsPerShaderArray = in_ext->computeUnitsPerShaderArray;
21781             out_ext->simdPerComputeUnit = in_ext->simdPerComputeUnit;
21782             out_ext->wavefrontsPerSimd = in_ext->wavefrontsPerSimd;
21783             out_ext->wavefrontSize = in_ext->wavefrontSize;
21784             out_ext->sgprsPerSimd = in_ext->sgprsPerSimd;
21785             out_ext->minSgprAllocation = in_ext->minSgprAllocation;
21786             out_ext->maxSgprAllocation = in_ext->maxSgprAllocation;
21787             out_ext->sgprAllocationGranularity = in_ext->sgprAllocationGranularity;
21788             out_ext->vgprsPerSimd = in_ext->vgprsPerSimd;
21789             out_ext->minVgprAllocation = in_ext->minVgprAllocation;
21790             out_ext->maxVgprAllocation = in_ext->maxVgprAllocation;
21791             out_ext->vgprAllocationGranularity = in_ext->vgprAllocationGranularity;
21792             out_header = (void *)out_ext;
21793             break;
21794         }
21795         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
21796         {
21797             VkPhysicalDeviceShaderCoreProperties2AMD32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD);
21798             const VkPhysicalDeviceShaderCoreProperties2AMD *in_ext = (const VkPhysicalDeviceShaderCoreProperties2AMD *)in_header;
21799             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
21800             out_ext->shaderCoreFeatures = in_ext->shaderCoreFeatures;
21801             out_ext->activeComputeUnitCount = in_ext->activeComputeUnitCount;
21802             out_header = (void *)out_ext;
21803             break;
21804         }
21805         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
21806         {
21807             VkPhysicalDeviceDescriptorIndexingProperties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
21808             const VkPhysicalDeviceDescriptorIndexingProperties *in_ext = (const VkPhysicalDeviceDescriptorIndexingProperties *)in_header;
21809             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
21810             out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools;
21811             out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative;
21812             out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative;
21813             out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative;
21814             out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative;
21815             out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative;
21816             out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind;
21817             out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod;
21818             out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers;
21819             out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
21820             out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
21821             out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages;
21822             out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages;
21823             out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments;
21824             out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources;
21825             out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers;
21826             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers;
21827             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
21828             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers;
21829             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
21830             out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages;
21831             out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages;
21832             out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments;
21833             out_header = (void *)out_ext;
21834             break;
21835         }
21836         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
21837         {
21838             VkPhysicalDeviceTimelineSemaphoreProperties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
21839             const VkPhysicalDeviceTimelineSemaphoreProperties *in_ext = (const VkPhysicalDeviceTimelineSemaphoreProperties *)in_header;
21840             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
21841             out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference;
21842             out_header = (void *)out_ext;
21843             break;
21844         }
21845         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
21846         {
21847             VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT);
21848             const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)in_header;
21849             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
21850             out_ext->maxVertexAttribDivisor = in_ext->maxVertexAttribDivisor;
21851             out_header = (void *)out_ext;
21852             break;
21853         }
21854         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
21855         {
21856             VkPhysicalDevicePCIBusInfoPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT);
21857             const VkPhysicalDevicePCIBusInfoPropertiesEXT *in_ext = (const VkPhysicalDevicePCIBusInfoPropertiesEXT *)in_header;
21858             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
21859             out_ext->pciDomain = in_ext->pciDomain;
21860             out_ext->pciBus = in_ext->pciBus;
21861             out_ext->pciDevice = in_ext->pciDevice;
21862             out_ext->pciFunction = in_ext->pciFunction;
21863             out_header = (void *)out_ext;
21864             break;
21865         }
21866         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
21867         {
21868             VkPhysicalDeviceDepthStencilResolveProperties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
21869             const VkPhysicalDeviceDepthStencilResolveProperties *in_ext = (const VkPhysicalDeviceDepthStencilResolveProperties *)in_header;
21870             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
21871             out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes;
21872             out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes;
21873             out_ext->independentResolveNone = in_ext->independentResolveNone;
21874             out_ext->independentResolve = in_ext->independentResolve;
21875             out_header = (void *)out_ext;
21876             break;
21877         }
21878         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
21879         {
21880             VkPhysicalDeviceTransformFeedbackPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
21881             const VkPhysicalDeviceTransformFeedbackPropertiesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)in_header;
21882             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
21883             out_ext->maxTransformFeedbackStreams = in_ext->maxTransformFeedbackStreams;
21884             out_ext->maxTransformFeedbackBuffers = in_ext->maxTransformFeedbackBuffers;
21885             out_ext->maxTransformFeedbackBufferSize = in_ext->maxTransformFeedbackBufferSize;
21886             out_ext->maxTransformFeedbackStreamDataSize = in_ext->maxTransformFeedbackStreamDataSize;
21887             out_ext->maxTransformFeedbackBufferDataSize = in_ext->maxTransformFeedbackBufferDataSize;
21888             out_ext->maxTransformFeedbackBufferDataStride = in_ext->maxTransformFeedbackBufferDataStride;
21889             out_ext->transformFeedbackQueries = in_ext->transformFeedbackQueries;
21890             out_ext->transformFeedbackStreamsLinesTriangles = in_ext->transformFeedbackStreamsLinesTriangles;
21891             out_ext->transformFeedbackRasterizationStreamSelect = in_ext->transformFeedbackRasterizationStreamSelect;
21892             out_ext->transformFeedbackDraw = in_ext->transformFeedbackDraw;
21893             out_header = (void *)out_ext;
21894             break;
21895         }
21896         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
21897         {
21898             VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV);
21899             const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *)in_header;
21900             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
21901             out_ext->supportedQueues = in_ext->supportedQueues;
21902             out_header = (void *)out_ext;
21903             break;
21904         }
21905         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
21906         {
21907             VkPhysicalDeviceMemoryDecompressionPropertiesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV);
21908             const VkPhysicalDeviceMemoryDecompressionPropertiesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionPropertiesNV *)in_header;
21909             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV;
21910             out_ext->decompressionMethods = in_ext->decompressionMethods;
21911             out_ext->maxDecompressionIndirectCount = in_ext->maxDecompressionIndirectCount;
21912             out_header = (void *)out_ext;
21913             break;
21914         }
21915         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
21916         {
21917             VkPhysicalDeviceShadingRateImagePropertiesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV);
21918             const VkPhysicalDeviceShadingRateImagePropertiesNV *in_ext = (const VkPhysicalDeviceShadingRateImagePropertiesNV *)in_header;
21919             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV;
21920             out_ext->shadingRateTexelSize = in_ext->shadingRateTexelSize;
21921             out_ext->shadingRatePaletteSize = in_ext->shadingRatePaletteSize;
21922             out_ext->shadingRateMaxCoarseSamples = in_ext->shadingRateMaxCoarseSamples;
21923             out_header = (void *)out_ext;
21924             break;
21925         }
21926         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
21927         {
21928             VkPhysicalDeviceMeshShaderPropertiesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV);
21929             const VkPhysicalDeviceMeshShaderPropertiesNV *in_ext = (const VkPhysicalDeviceMeshShaderPropertiesNV *)in_header;
21930             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV;
21931             out_ext->maxDrawMeshTasksCount = in_ext->maxDrawMeshTasksCount;
21932             out_ext->maxTaskWorkGroupInvocations = in_ext->maxTaskWorkGroupInvocations;
21933             memcpy(out_ext->maxTaskWorkGroupSize, in_ext->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
21934             out_ext->maxTaskTotalMemorySize = in_ext->maxTaskTotalMemorySize;
21935             out_ext->maxTaskOutputCount = in_ext->maxTaskOutputCount;
21936             out_ext->maxMeshWorkGroupInvocations = in_ext->maxMeshWorkGroupInvocations;
21937             memcpy(out_ext->maxMeshWorkGroupSize, in_ext->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
21938             out_ext->maxMeshTotalMemorySize = in_ext->maxMeshTotalMemorySize;
21939             out_ext->maxMeshOutputVertices = in_ext->maxMeshOutputVertices;
21940             out_ext->maxMeshOutputPrimitives = in_ext->maxMeshOutputPrimitives;
21941             out_ext->maxMeshMultiviewViewCount = in_ext->maxMeshMultiviewViewCount;
21942             out_ext->meshOutputPerVertexGranularity = in_ext->meshOutputPerVertexGranularity;
21943             out_ext->meshOutputPerPrimitiveGranularity = in_ext->meshOutputPerPrimitiveGranularity;
21944             out_header = (void *)out_ext;
21945             break;
21946         }
21947         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
21948         {
21949             VkPhysicalDeviceMeshShaderPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT);
21950             const VkPhysicalDeviceMeshShaderPropertiesEXT *in_ext = (const VkPhysicalDeviceMeshShaderPropertiesEXT *)in_header;
21951             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
21952             out_ext->maxTaskWorkGroupTotalCount = in_ext->maxTaskWorkGroupTotalCount;
21953             memcpy(out_ext->maxTaskWorkGroupCount, in_ext->maxTaskWorkGroupCount, 3 * sizeof(uint32_t));
21954             out_ext->maxTaskWorkGroupInvocations = in_ext->maxTaskWorkGroupInvocations;
21955             memcpy(out_ext->maxTaskWorkGroupSize, in_ext->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
21956             out_ext->maxTaskPayloadSize = in_ext->maxTaskPayloadSize;
21957             out_ext->maxTaskSharedMemorySize = in_ext->maxTaskSharedMemorySize;
21958             out_ext->maxTaskPayloadAndSharedMemorySize = in_ext->maxTaskPayloadAndSharedMemorySize;
21959             out_ext->maxMeshWorkGroupTotalCount = in_ext->maxMeshWorkGroupTotalCount;
21960             memcpy(out_ext->maxMeshWorkGroupCount, in_ext->maxMeshWorkGroupCount, 3 * sizeof(uint32_t));
21961             out_ext->maxMeshWorkGroupInvocations = in_ext->maxMeshWorkGroupInvocations;
21962             memcpy(out_ext->maxMeshWorkGroupSize, in_ext->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
21963             out_ext->maxMeshSharedMemorySize = in_ext->maxMeshSharedMemorySize;
21964             out_ext->maxMeshPayloadAndSharedMemorySize = in_ext->maxMeshPayloadAndSharedMemorySize;
21965             out_ext->maxMeshOutputMemorySize = in_ext->maxMeshOutputMemorySize;
21966             out_ext->maxMeshPayloadAndOutputMemorySize = in_ext->maxMeshPayloadAndOutputMemorySize;
21967             out_ext->maxMeshOutputComponents = in_ext->maxMeshOutputComponents;
21968             out_ext->maxMeshOutputVertices = in_ext->maxMeshOutputVertices;
21969             out_ext->maxMeshOutputPrimitives = in_ext->maxMeshOutputPrimitives;
21970             out_ext->maxMeshOutputLayers = in_ext->maxMeshOutputLayers;
21971             out_ext->maxMeshMultiviewViewCount = in_ext->maxMeshMultiviewViewCount;
21972             out_ext->meshOutputPerVertexGranularity = in_ext->meshOutputPerVertexGranularity;
21973             out_ext->meshOutputPerPrimitiveGranularity = in_ext->meshOutputPerPrimitiveGranularity;
21974             out_ext->maxPreferredTaskWorkGroupInvocations = in_ext->maxPreferredTaskWorkGroupInvocations;
21975             out_ext->maxPreferredMeshWorkGroupInvocations = in_ext->maxPreferredMeshWorkGroupInvocations;
21976             out_ext->prefersLocalInvocationVertexOutput = in_ext->prefersLocalInvocationVertexOutput;
21977             out_ext->prefersLocalInvocationPrimitiveOutput = in_ext->prefersLocalInvocationPrimitiveOutput;
21978             out_ext->prefersCompactVertexOutput = in_ext->prefersCompactVertexOutput;
21979             out_ext->prefersCompactPrimitiveOutput = in_ext->prefersCompactPrimitiveOutput;
21980             out_header = (void *)out_ext;
21981             break;
21982         }
21983         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
21984         {
21985             VkPhysicalDeviceAccelerationStructurePropertiesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR);
21986             const VkPhysicalDeviceAccelerationStructurePropertiesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructurePropertiesKHR *)in_header;
21987             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
21988             out_ext->maxGeometryCount = in_ext->maxGeometryCount;
21989             out_ext->maxInstanceCount = in_ext->maxInstanceCount;
21990             out_ext->maxPrimitiveCount = in_ext->maxPrimitiveCount;
21991             out_ext->maxPerStageDescriptorAccelerationStructures = in_ext->maxPerStageDescriptorAccelerationStructures;
21992             out_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures = in_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
21993             out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures;
21994             out_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures = in_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures;
21995             out_ext->minAccelerationStructureScratchOffsetAlignment = in_ext->minAccelerationStructureScratchOffsetAlignment;
21996             out_header = (void *)out_ext;
21997             break;
21998         }
21999         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
22000         {
22001             VkPhysicalDeviceRayTracingPipelinePropertiesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR);
22002             const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *)in_header;
22003             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
22004             out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize;
22005             out_ext->maxRayRecursionDepth = in_ext->maxRayRecursionDepth;
22006             out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride;
22007             out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment;
22008             out_ext->shaderGroupHandleCaptureReplaySize = in_ext->shaderGroupHandleCaptureReplaySize;
22009             out_ext->maxRayDispatchInvocationCount = in_ext->maxRayDispatchInvocationCount;
22010             out_ext->shaderGroupHandleAlignment = in_ext->shaderGroupHandleAlignment;
22011             out_ext->maxRayHitAttributeSize = in_ext->maxRayHitAttributeSize;
22012             out_header = (void *)out_ext;
22013             break;
22014         }
22015         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
22016         {
22017             VkPhysicalDeviceRayTracingPropertiesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV);
22018             const VkPhysicalDeviceRayTracingPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingPropertiesNV *)in_header;
22019             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
22020             out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize;
22021             out_ext->maxRecursionDepth = in_ext->maxRecursionDepth;
22022             out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride;
22023             out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment;
22024             out_ext->maxGeometryCount = in_ext->maxGeometryCount;
22025             out_ext->maxInstanceCount = in_ext->maxInstanceCount;
22026             out_ext->maxTriangleCount = in_ext->maxTriangleCount;
22027             out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures;
22028             out_header = (void *)out_ext;
22029             break;
22030         }
22031         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
22032         {
22033             VkPhysicalDeviceFragmentDensityMapPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT);
22034             const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *)in_header;
22035             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
22036             out_ext->minFragmentDensityTexelSize = in_ext->minFragmentDensityTexelSize;
22037             out_ext->maxFragmentDensityTexelSize = in_ext->maxFragmentDensityTexelSize;
22038             out_ext->fragmentDensityInvocations = in_ext->fragmentDensityInvocations;
22039             out_header = (void *)out_ext;
22040             break;
22041         }
22042         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
22043         {
22044             VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT);
22045             const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *)in_header;
22046             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
22047             out_ext->subsampledLoads = in_ext->subsampledLoads;
22048             out_ext->subsampledCoarseReconstructionEarlyAccess = in_ext->subsampledCoarseReconstructionEarlyAccess;
22049             out_ext->maxSubsampledArrayLayers = in_ext->maxSubsampledArrayLayers;
22050             out_ext->maxDescriptorSetSubsampledSamplers = in_ext->maxDescriptorSetSubsampledSamplers;
22051             out_header = (void *)out_ext;
22052             break;
22053         }
22054         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
22055         {
22056             VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM);
22057             const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *)in_header;
22058             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM;
22059             out_ext->fragmentDensityOffsetGranularity = in_ext->fragmentDensityOffsetGranularity;
22060             out_header = (void *)out_ext;
22061             break;
22062         }
22063         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
22064         {
22065             VkPhysicalDeviceCooperativeMatrixPropertiesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV);
22066             const VkPhysicalDeviceCooperativeMatrixPropertiesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixPropertiesNV *)in_header;
22067             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV;
22068             out_ext->cooperativeMatrixSupportedStages = in_ext->cooperativeMatrixSupportedStages;
22069             out_header = (void *)out_ext;
22070             break;
22071         }
22072         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
22073         {
22074             VkPhysicalDevicePerformanceQueryPropertiesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR);
22075             const VkPhysicalDevicePerformanceQueryPropertiesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryPropertiesKHR *)in_header;
22076             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
22077             out_ext->allowCommandBufferQueryCopies = in_ext->allowCommandBufferQueryCopies;
22078             out_header = (void *)out_ext;
22079             break;
22080         }
22081         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
22082         {
22083             VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV);
22084             const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *)in_header;
22085             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
22086             out_ext->shaderSMCount = in_ext->shaderSMCount;
22087             out_ext->shaderWarpsPerSM = in_ext->shaderWarpsPerSM;
22088             out_header = (void *)out_ext;
22089             break;
22090         }
22091         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
22092         {
22093             VkPhysicalDeviceTexelBufferAlignmentProperties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES);
22094             const VkPhysicalDeviceTexelBufferAlignmentProperties *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentProperties *)in_header;
22095             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
22096             out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes;
22097             out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment;
22098             out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes;
22099             out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment;
22100             out_header = (void *)out_ext;
22101             break;
22102         }
22103         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
22104         {
22105             VkPhysicalDeviceSubgroupSizeControlProperties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES);
22106             const VkPhysicalDeviceSubgroupSizeControlProperties *in_ext = (const VkPhysicalDeviceSubgroupSizeControlProperties *)in_header;
22107             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
22108             out_ext->minSubgroupSize = in_ext->minSubgroupSize;
22109             out_ext->maxSubgroupSize = in_ext->maxSubgroupSize;
22110             out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups;
22111             out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages;
22112             out_header = (void *)out_ext;
22113             break;
22114         }
22115         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
22116         {
22117             VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI);
22118             const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *)in_header;
22119             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI;
22120             out_ext->maxSubpassShadingWorkgroupSizeAspectRatio = in_ext->maxSubpassShadingWorkgroupSizeAspectRatio;
22121             out_header = (void *)out_ext;
22122             break;
22123         }
22124         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
22125         {
22126             VkPhysicalDeviceLineRasterizationPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT);
22127             const VkPhysicalDeviceLineRasterizationPropertiesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationPropertiesEXT *)in_header;
22128             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT;
22129             out_ext->lineSubPixelPrecisionBits = in_ext->lineSubPixelPrecisionBits;
22130             out_header = (void *)out_ext;
22131             break;
22132         }
22133         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
22134         {
22135             VkPhysicalDeviceVulkan11Properties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
22136             const VkPhysicalDeviceVulkan11Properties *in_ext = (const VkPhysicalDeviceVulkan11Properties *)in_header;
22137             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
22138             memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
22139             memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
22140             memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
22141             out_ext->deviceNodeMask = in_ext->deviceNodeMask;
22142             out_ext->deviceLUIDValid = in_ext->deviceLUIDValid;
22143             out_ext->subgroupSize = in_ext->subgroupSize;
22144             out_ext->subgroupSupportedStages = in_ext->subgroupSupportedStages;
22145             out_ext->subgroupSupportedOperations = in_ext->subgroupSupportedOperations;
22146             out_ext->subgroupQuadOperationsInAllStages = in_ext->subgroupQuadOperationsInAllStages;
22147             out_ext->pointClippingBehavior = in_ext->pointClippingBehavior;
22148             out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount;
22149             out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex;
22150             out_ext->protectedNoFault = in_ext->protectedNoFault;
22151             out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors;
22152             out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize;
22153             out_header = (void *)out_ext;
22154             break;
22155         }
22156         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
22157         {
22158             VkPhysicalDeviceVulkan12Properties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
22159             const VkPhysicalDeviceVulkan12Properties *in_ext = (const VkPhysicalDeviceVulkan12Properties *)in_header;
22160             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
22161             out_ext->driverID = in_ext->driverID;
22162             memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
22163             memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
22164             out_ext->conformanceVersion = in_ext->conformanceVersion;
22165             out_ext->denormBehaviorIndependence = in_ext->denormBehaviorIndependence;
22166             out_ext->roundingModeIndependence = in_ext->roundingModeIndependence;
22167             out_ext->shaderSignedZeroInfNanPreserveFloat16 = in_ext->shaderSignedZeroInfNanPreserveFloat16;
22168             out_ext->shaderSignedZeroInfNanPreserveFloat32 = in_ext->shaderSignedZeroInfNanPreserveFloat32;
22169             out_ext->shaderSignedZeroInfNanPreserveFloat64 = in_ext->shaderSignedZeroInfNanPreserveFloat64;
22170             out_ext->shaderDenormPreserveFloat16 = in_ext->shaderDenormPreserveFloat16;
22171             out_ext->shaderDenormPreserveFloat32 = in_ext->shaderDenormPreserveFloat32;
22172             out_ext->shaderDenormPreserveFloat64 = in_ext->shaderDenormPreserveFloat64;
22173             out_ext->shaderDenormFlushToZeroFloat16 = in_ext->shaderDenormFlushToZeroFloat16;
22174             out_ext->shaderDenormFlushToZeroFloat32 = in_ext->shaderDenormFlushToZeroFloat32;
22175             out_ext->shaderDenormFlushToZeroFloat64 = in_ext->shaderDenormFlushToZeroFloat64;
22176             out_ext->shaderRoundingModeRTEFloat16 = in_ext->shaderRoundingModeRTEFloat16;
22177             out_ext->shaderRoundingModeRTEFloat32 = in_ext->shaderRoundingModeRTEFloat32;
22178             out_ext->shaderRoundingModeRTEFloat64 = in_ext->shaderRoundingModeRTEFloat64;
22179             out_ext->shaderRoundingModeRTZFloat16 = in_ext->shaderRoundingModeRTZFloat16;
22180             out_ext->shaderRoundingModeRTZFloat32 = in_ext->shaderRoundingModeRTZFloat32;
22181             out_ext->shaderRoundingModeRTZFloat64 = in_ext->shaderRoundingModeRTZFloat64;
22182             out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools;
22183             out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative;
22184             out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative;
22185             out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative;
22186             out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative;
22187             out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative;
22188             out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind;
22189             out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod;
22190             out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers;
22191             out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
22192             out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
22193             out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages;
22194             out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages;
22195             out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments;
22196             out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources;
22197             out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers;
22198             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers;
22199             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
22200             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers;
22201             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
22202             out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages;
22203             out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages;
22204             out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments;
22205             out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes;
22206             out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes;
22207             out_ext->independentResolveNone = in_ext->independentResolveNone;
22208             out_ext->independentResolve = in_ext->independentResolve;
22209             out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats;
22210             out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping;
22211             out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference;
22212             out_ext->framebufferIntegerColorSampleCounts = in_ext->framebufferIntegerColorSampleCounts;
22213             out_header = (void *)out_ext;
22214             break;
22215         }
22216         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
22217         {
22218             VkPhysicalDeviceVulkan13Properties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES);
22219             const VkPhysicalDeviceVulkan13Properties *in_ext = (const VkPhysicalDeviceVulkan13Properties *)in_header;
22220             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
22221             out_ext->minSubgroupSize = in_ext->minSubgroupSize;
22222             out_ext->maxSubgroupSize = in_ext->maxSubgroupSize;
22223             out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups;
22224             out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages;
22225             out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize;
22226             out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks;
22227             out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
22228             out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks;
22229             out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
22230             out_ext->maxInlineUniformTotalSize = in_ext->maxInlineUniformTotalSize;
22231             out_ext->integerDotProduct8BitUnsignedAccelerated = in_ext->integerDotProduct8BitUnsignedAccelerated;
22232             out_ext->integerDotProduct8BitSignedAccelerated = in_ext->integerDotProduct8BitSignedAccelerated;
22233             out_ext->integerDotProduct8BitMixedSignednessAccelerated = in_ext->integerDotProduct8BitMixedSignednessAccelerated;
22234             out_ext->integerDotProduct4x8BitPackedUnsignedAccelerated = in_ext->integerDotProduct4x8BitPackedUnsignedAccelerated;
22235             out_ext->integerDotProduct4x8BitPackedSignedAccelerated = in_ext->integerDotProduct4x8BitPackedSignedAccelerated;
22236             out_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated;
22237             out_ext->integerDotProduct16BitUnsignedAccelerated = in_ext->integerDotProduct16BitUnsignedAccelerated;
22238             out_ext->integerDotProduct16BitSignedAccelerated = in_ext->integerDotProduct16BitSignedAccelerated;
22239             out_ext->integerDotProduct16BitMixedSignednessAccelerated = in_ext->integerDotProduct16BitMixedSignednessAccelerated;
22240             out_ext->integerDotProduct32BitUnsignedAccelerated = in_ext->integerDotProduct32BitUnsignedAccelerated;
22241             out_ext->integerDotProduct32BitSignedAccelerated = in_ext->integerDotProduct32BitSignedAccelerated;
22242             out_ext->integerDotProduct32BitMixedSignednessAccelerated = in_ext->integerDotProduct32BitMixedSignednessAccelerated;
22243             out_ext->integerDotProduct64BitUnsignedAccelerated = in_ext->integerDotProduct64BitUnsignedAccelerated;
22244             out_ext->integerDotProduct64BitSignedAccelerated = in_ext->integerDotProduct64BitSignedAccelerated;
22245             out_ext->integerDotProduct64BitMixedSignednessAccelerated = in_ext->integerDotProduct64BitMixedSignednessAccelerated;
22246             out_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
22247             out_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated;
22248             out_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
22249             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
22250             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
22251             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
22252             out_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
22253             out_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated;
22254             out_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
22255             out_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
22256             out_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated;
22257             out_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
22258             out_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
22259             out_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated;
22260             out_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
22261             out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes;
22262             out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment;
22263             out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes;
22264             out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment;
22265             out_ext->maxBufferSize = in_ext->maxBufferSize;
22266             out_header = (void *)out_ext;
22267             break;
22268         }
22269         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
22270         {
22271             VkPhysicalDeviceCustomBorderColorPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT);
22272             const VkPhysicalDeviceCustomBorderColorPropertiesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorPropertiesEXT *)in_header;
22273             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
22274             out_ext->maxCustomBorderColorSamplers = in_ext->maxCustomBorderColorSamplers;
22275             out_header = (void *)out_ext;
22276             break;
22277         }
22278         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
22279         {
22280             VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT);
22281             const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *)in_header;
22282             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
22283             out_ext->dynamicPrimitiveTopologyUnrestricted = in_ext->dynamicPrimitiveTopologyUnrestricted;
22284             out_header = (void *)out_ext;
22285             break;
22286         }
22287         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
22288         {
22289             VkPhysicalDeviceRobustness2PropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT);
22290             const VkPhysicalDeviceRobustness2PropertiesEXT *in_ext = (const VkPhysicalDeviceRobustness2PropertiesEXT *)in_header;
22291             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT;
22292             out_ext->robustStorageBufferAccessSizeAlignment = in_ext->robustStorageBufferAccessSizeAlignment;
22293             out_ext->robustUniformBufferAccessSizeAlignment = in_ext->robustUniformBufferAccessSizeAlignment;
22294             out_header = (void *)out_ext;
22295             break;
22296         }
22297         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
22298         {
22299             VkPhysicalDeviceFragmentShadingRatePropertiesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR);
22300             const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)in_header;
22301             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
22302             out_ext->minFragmentShadingRateAttachmentTexelSize = in_ext->minFragmentShadingRateAttachmentTexelSize;
22303             out_ext->maxFragmentShadingRateAttachmentTexelSize = in_ext->maxFragmentShadingRateAttachmentTexelSize;
22304             out_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio = in_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
22305             out_ext->primitiveFragmentShadingRateWithMultipleViewports = in_ext->primitiveFragmentShadingRateWithMultipleViewports;
22306             out_ext->layeredShadingRateAttachments = in_ext->layeredShadingRateAttachments;
22307             out_ext->fragmentShadingRateNonTrivialCombinerOps = in_ext->fragmentShadingRateNonTrivialCombinerOps;
22308             out_ext->maxFragmentSize = in_ext->maxFragmentSize;
22309             out_ext->maxFragmentSizeAspectRatio = in_ext->maxFragmentSizeAspectRatio;
22310             out_ext->maxFragmentShadingRateCoverageSamples = in_ext->maxFragmentShadingRateCoverageSamples;
22311             out_ext->maxFragmentShadingRateRasterizationSamples = in_ext->maxFragmentShadingRateRasterizationSamples;
22312             out_ext->fragmentShadingRateWithShaderDepthStencilWrites = in_ext->fragmentShadingRateWithShaderDepthStencilWrites;
22313             out_ext->fragmentShadingRateWithSampleMask = in_ext->fragmentShadingRateWithSampleMask;
22314             out_ext->fragmentShadingRateWithShaderSampleMask = in_ext->fragmentShadingRateWithShaderSampleMask;
22315             out_ext->fragmentShadingRateWithConservativeRasterization = in_ext->fragmentShadingRateWithConservativeRasterization;
22316             out_ext->fragmentShadingRateWithFragmentShaderInterlock = in_ext->fragmentShadingRateWithFragmentShaderInterlock;
22317             out_ext->fragmentShadingRateWithCustomSampleLocations = in_ext->fragmentShadingRateWithCustomSampleLocations;
22318             out_ext->fragmentShadingRateStrictMultiplyCombiner = in_ext->fragmentShadingRateStrictMultiplyCombiner;
22319             out_header = (void *)out_ext;
22320             break;
22321         }
22322         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
22323         {
22324             VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV);
22325             const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *)in_header;
22326             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV;
22327             out_ext->maxFragmentShadingRateInvocationCount = in_ext->maxFragmentShadingRateInvocationCount;
22328             out_header = (void *)out_ext;
22329             break;
22330         }
22331         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
22332         {
22333             VkPhysicalDeviceProvokingVertexPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT);
22334             const VkPhysicalDeviceProvokingVertexPropertiesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexPropertiesEXT *)in_header;
22335             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
22336             out_ext->provokingVertexModePerPipeline = in_ext->provokingVertexModePerPipeline;
22337             out_ext->transformFeedbackPreservesTriangleFanProvokingVertex = in_ext->transformFeedbackPreservesTriangleFanProvokingVertex;
22338             out_header = (void *)out_ext;
22339             break;
22340         }
22341         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
22342         {
22343             VkPhysicalDeviceShaderIntegerDotProductProperties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES);
22344             const VkPhysicalDeviceShaderIntegerDotProductProperties *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductProperties *)in_header;
22345             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
22346             out_ext->integerDotProduct8BitUnsignedAccelerated = in_ext->integerDotProduct8BitUnsignedAccelerated;
22347             out_ext->integerDotProduct8BitSignedAccelerated = in_ext->integerDotProduct8BitSignedAccelerated;
22348             out_ext->integerDotProduct8BitMixedSignednessAccelerated = in_ext->integerDotProduct8BitMixedSignednessAccelerated;
22349             out_ext->integerDotProduct4x8BitPackedUnsignedAccelerated = in_ext->integerDotProduct4x8BitPackedUnsignedAccelerated;
22350             out_ext->integerDotProduct4x8BitPackedSignedAccelerated = in_ext->integerDotProduct4x8BitPackedSignedAccelerated;
22351             out_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated;
22352             out_ext->integerDotProduct16BitUnsignedAccelerated = in_ext->integerDotProduct16BitUnsignedAccelerated;
22353             out_ext->integerDotProduct16BitSignedAccelerated = in_ext->integerDotProduct16BitSignedAccelerated;
22354             out_ext->integerDotProduct16BitMixedSignednessAccelerated = in_ext->integerDotProduct16BitMixedSignednessAccelerated;
22355             out_ext->integerDotProduct32BitUnsignedAccelerated = in_ext->integerDotProduct32BitUnsignedAccelerated;
22356             out_ext->integerDotProduct32BitSignedAccelerated = in_ext->integerDotProduct32BitSignedAccelerated;
22357             out_ext->integerDotProduct32BitMixedSignednessAccelerated = in_ext->integerDotProduct32BitMixedSignednessAccelerated;
22358             out_ext->integerDotProduct64BitUnsignedAccelerated = in_ext->integerDotProduct64BitUnsignedAccelerated;
22359             out_ext->integerDotProduct64BitSignedAccelerated = in_ext->integerDotProduct64BitSignedAccelerated;
22360             out_ext->integerDotProduct64BitMixedSignednessAccelerated = in_ext->integerDotProduct64BitMixedSignednessAccelerated;
22361             out_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
22362             out_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated;
22363             out_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
22364             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
22365             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
22366             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
22367             out_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
22368             out_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated;
22369             out_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
22370             out_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
22371             out_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated;
22372             out_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
22373             out_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
22374             out_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated;
22375             out_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
22376             out_header = (void *)out_ext;
22377             break;
22378         }
22379         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
22380         {
22381             VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR);
22382             const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *)in_header;
22383             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
22384             out_ext->triStripVertexOrderIndependentOfProvokingVertex = in_ext->triStripVertexOrderIndependentOfProvokingVertex;
22385             out_header = (void *)out_ext;
22386             break;
22387         }
22388         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
22389         {
22390             VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT);
22391             const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *)in_header;
22392             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
22393             out_ext->graphicsPipelineLibraryFastLinking = in_ext->graphicsPipelineLibraryFastLinking;
22394             out_ext->graphicsPipelineLibraryIndependentInterpolationDecoration = in_ext->graphicsPipelineLibraryIndependentInterpolationDecoration;
22395             out_header = (void *)out_ext;
22396             break;
22397         }
22398         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
22399         {
22400             VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT);
22401             const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *)in_header;
22402             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
22403             memcpy(out_ext->shaderModuleIdentifierAlgorithmUUID, in_ext->shaderModuleIdentifierAlgorithmUUID, VK_UUID_SIZE * sizeof(uint8_t));
22404             out_header = (void *)out_ext;
22405             break;
22406         }
22407         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
22408         {
22409             VkPhysicalDeviceOpacityMicromapPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT);
22410             const VkPhysicalDeviceOpacityMicromapPropertiesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapPropertiesEXT *)in_header;
22411             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
22412             out_ext->maxOpacity2StateSubdivisionLevel = in_ext->maxOpacity2StateSubdivisionLevel;
22413             out_ext->maxOpacity4StateSubdivisionLevel = in_ext->maxOpacity4StateSubdivisionLevel;
22414             out_header = (void *)out_ext;
22415             break;
22416         }
22417         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
22418         {
22419             VkPhysicalDevicePipelineRobustnessPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT);
22420             const VkPhysicalDevicePipelineRobustnessPropertiesEXT *in_ext = (const VkPhysicalDevicePipelineRobustnessPropertiesEXT *)in_header;
22421             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT;
22422             out_ext->defaultRobustnessStorageBuffers = in_ext->defaultRobustnessStorageBuffers;
22423             out_ext->defaultRobustnessUniformBuffers = in_ext->defaultRobustnessUniformBuffers;
22424             out_ext->defaultRobustnessVertexInputs = in_ext->defaultRobustnessVertexInputs;
22425             out_ext->defaultRobustnessImages = in_ext->defaultRobustnessImages;
22426             out_header = (void *)out_ext;
22427             break;
22428         }
22429         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
22430         {
22431             VkPhysicalDeviceImageProcessingPropertiesQCOM32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM);
22432             const VkPhysicalDeviceImageProcessingPropertiesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingPropertiesQCOM *)in_header;
22433             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM;
22434             out_ext->maxWeightFilterPhases = in_ext->maxWeightFilterPhases;
22435             out_ext->maxWeightFilterDimension = in_ext->maxWeightFilterDimension;
22436             out_ext->maxBlockMatchRegion = in_ext->maxBlockMatchRegion;
22437             out_ext->maxBoxFilterBlockSize = in_ext->maxBoxFilterBlockSize;
22438             out_header = (void *)out_ext;
22439             break;
22440         }
22441         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
22442         {
22443             VkPhysicalDeviceOpticalFlowPropertiesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV);
22444             const VkPhysicalDeviceOpticalFlowPropertiesNV *in_ext = (const VkPhysicalDeviceOpticalFlowPropertiesNV *)in_header;
22445             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV;
22446             out_ext->supportedOutputGridSizes = in_ext->supportedOutputGridSizes;
22447             out_ext->supportedHintGridSizes = in_ext->supportedHintGridSizes;
22448             out_ext->hintSupported = in_ext->hintSupported;
22449             out_ext->costSupported = in_ext->costSupported;
22450             out_ext->bidirectionalFlowSupported = in_ext->bidirectionalFlowSupported;
22451             out_ext->globalFlowSupported = in_ext->globalFlowSupported;
22452             out_ext->minWidth = in_ext->minWidth;
22453             out_ext->minHeight = in_ext->minHeight;
22454             out_ext->maxWidth = in_ext->maxWidth;
22455             out_ext->maxHeight = in_ext->maxHeight;
22456             out_ext->maxNumRegionsOfInterest = in_ext->maxNumRegionsOfInterest;
22457             out_header = (void *)out_ext;
22458             break;
22459         }
22460         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
22461         {
22462             VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM);
22463             const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *)in_header;
22464             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM;
22465             out_ext->shaderCoreMask = in_ext->shaderCoreMask;
22466             out_ext->shaderCoreCount = in_ext->shaderCoreCount;
22467             out_ext->shaderWarpsPerCore = in_ext->shaderWarpsPerCore;
22468             out_header = (void *)out_ext;
22469             break;
22470         }
22471         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
22472         {
22473             VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV);
22474             const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *)in_header;
22475             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV;
22476             out_ext->rayTracingInvocationReorderReorderingHint = in_ext->rayTracingInvocationReorderReorderingHint;
22477             out_header = (void *)out_ext;
22478             break;
22479         }
22480         default:
22481             break;
22482         }
22483     }
22484 }
22485 #endif /* USE_STRUCT_CONVERSION */
22486
22487 #if defined(USE_STRUCT_CONVERSION)
22488 static inline void convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host(const VkQueryPoolPerformanceCreateInfoKHR32 *in, VkQueryPoolPerformanceCreateInfoKHR *out)
22489 {
22490     if (!in) return;
22491
22492     out->sType = in->sType;
22493     out->pNext = in->pNext;
22494     out->queueFamilyIndex = in->queueFamilyIndex;
22495     out->counterIndexCount = in->counterIndexCount;
22496     out->pCounterIndices = in->pCounterIndices;
22497 }
22498 #endif /* USE_STRUCT_CONVERSION */
22499
22500 #if defined(USE_STRUCT_CONVERSION)
22501 static inline void convert_VkQueueFamilyProperties2_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyProperties232 *in, VkQueueFamilyProperties2 *out)
22502 {
22503     const VkBaseInStructure *in_header;
22504     VkBaseOutStructure *out_header = (void *)out;
22505
22506     if (!in) return;
22507
22508     out->sType = in->sType;
22509     out->pNext = NULL;
22510
22511     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
22512     {
22513         switch (in_header->sType)
22514         {
22515         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
22516         {
22517             VkQueueFamilyGlobalPriorityPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22518             const VkQueueFamilyGlobalPriorityPropertiesKHR32 *in_ext = (const VkQueueFamilyGlobalPriorityPropertiesKHR32 *)in_header;
22519             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR;
22520             out_ext->pNext = NULL;
22521             out_ext->priorityCount = in_ext->priorityCount;
22522             memcpy(out_ext->priorities, in_ext->priorities, VK_MAX_GLOBAL_PRIORITY_SIZE_KHR * sizeof(VkQueueGlobalPriorityKHR));
22523             out_header->pNext = (void *)out_ext;
22524             out_header = (void *)out_ext;
22525             break;
22526         }
22527         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
22528         {
22529             VkQueueFamilyCheckpointPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22530             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV;
22531             out_ext->pNext = NULL;
22532             out_header->pNext = (void *)out_ext;
22533             out_header = (void *)out_ext;
22534             break;
22535         }
22536         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
22537         {
22538             VkQueueFamilyCheckpointProperties2NV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22539             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV;
22540             out_ext->pNext = NULL;
22541             out_header->pNext = (void *)out_ext;
22542             out_header = (void *)out_ext;
22543             break;
22544         }
22545         default:
22546             FIXME("Unhandled sType %u.", in_header->sType);
22547             break;
22548         }
22549     }
22550 }
22551 #endif /* USE_STRUCT_CONVERSION */
22552
22553 #if defined(USE_STRUCT_CONVERSION)
22554 static inline void convert_VkQueueFamilyProperties2_host_to_win32(const VkQueueFamilyProperties2 *in, VkQueueFamilyProperties232 *out)
22555 {
22556     const VkBaseInStructure *in_header;
22557     VkBaseOutStructure *out_header = (void *)out;
22558
22559     if (!in) return;
22560
22561     out->queueFamilyProperties = in->queueFamilyProperties;
22562
22563     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
22564     {
22565         switch (in_header->sType)
22566         {
22567         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
22568         {
22569             VkQueueFamilyGlobalPriorityPropertiesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR);
22570             const VkQueueFamilyGlobalPriorityPropertiesKHR *in_ext = (const VkQueueFamilyGlobalPriorityPropertiesKHR *)in_header;
22571             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR;
22572             out_ext->priorityCount = in_ext->priorityCount;
22573             memcpy(out_ext->priorities, in_ext->priorities, VK_MAX_GLOBAL_PRIORITY_SIZE_KHR * sizeof(VkQueueGlobalPriorityKHR));
22574             out_header = (void *)out_ext;
22575             break;
22576         }
22577         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
22578         {
22579             VkQueueFamilyCheckpointPropertiesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV);
22580             const VkQueueFamilyCheckpointPropertiesNV *in_ext = (const VkQueueFamilyCheckpointPropertiesNV *)in_header;
22581             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV;
22582             out_ext->checkpointExecutionStageMask = in_ext->checkpointExecutionStageMask;
22583             out_header = (void *)out_ext;
22584             break;
22585         }
22586         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
22587         {
22588             VkQueueFamilyCheckpointProperties2NV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV);
22589             const VkQueueFamilyCheckpointProperties2NV *in_ext = (const VkQueueFamilyCheckpointProperties2NV *)in_header;
22590             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV;
22591             out_ext->checkpointExecutionStageMask = in_ext->checkpointExecutionStageMask;
22592             out_header = (void *)out_ext;
22593             break;
22594         }
22595         default:
22596             break;
22597         }
22598     }
22599 }
22600 #endif /* USE_STRUCT_CONVERSION */
22601
22602 #if defined(USE_STRUCT_CONVERSION)
22603 static inline VkQueueFamilyProperties2 *convert_VkQueueFamilyProperties2_array_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyProperties232 *in, uint32_t count)
22604 {
22605     VkQueueFamilyProperties2 *out;
22606     unsigned int i;
22607
22608     if (!in || !count) return NULL;
22609
22610     out = conversion_context_alloc(ctx, count * sizeof(*out));
22611     for (i = 0; i < count; i++)
22612     {
22613         convert_VkQueueFamilyProperties2_win32_to_host(ctx, &in[i], &out[i]);
22614     }
22615
22616     return out;
22617 }
22618 #endif /* USE_STRUCT_CONVERSION */
22619
22620 #if defined(USE_STRUCT_CONVERSION)
22621 static inline void convert_VkQueueFamilyProperties2_array_host_to_win32(const VkQueueFamilyProperties2 *in, VkQueueFamilyProperties232 *out, uint32_t count)
22622 {
22623     unsigned int i;
22624
22625     if (!in) return;
22626
22627     for (i = 0; i < count; i++)
22628     {
22629         convert_VkQueueFamilyProperties2_host_to_win32(&in[i], &out[i]);
22630     }
22631 }
22632 #endif /* USE_STRUCT_CONVERSION */
22633
22634 #if defined(USE_STRUCT_CONVERSION)
22635 static inline void convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(const VkPhysicalDeviceSparseImageFormatInfo232 *in, VkPhysicalDeviceSparseImageFormatInfo2 *out)
22636 {
22637     if (!in) return;
22638
22639     out->sType = in->sType;
22640     out->pNext = in->pNext;
22641     out->format = in->format;
22642     out->type = in->type;
22643     out->samples = in->samples;
22644     out->usage = in->usage;
22645     out->tiling = in->tiling;
22646 }
22647 #endif /* USE_STRUCT_CONVERSION */
22648
22649 #if defined(USE_STRUCT_CONVERSION)
22650 static inline void convert_VkSparseImageFormatProperties2_win32_to_host(const VkSparseImageFormatProperties232 *in, VkSparseImageFormatProperties2 *out)
22651 {
22652     if (!in) return;
22653
22654     out->sType = in->sType;
22655     out->pNext = in->pNext;
22656 }
22657 #endif /* USE_STRUCT_CONVERSION */
22658
22659 #if defined(USE_STRUCT_CONVERSION)
22660 static inline void convert_VkSparseImageFormatProperties2_host_to_win32(const VkSparseImageFormatProperties2 *in, VkSparseImageFormatProperties232 *out)
22661 {
22662     if (!in) return;
22663
22664     out->properties = in->properties;
22665 }
22666 #endif /* USE_STRUCT_CONVERSION */
22667
22668 #if defined(USE_STRUCT_CONVERSION)
22669 static inline VkSparseImageFormatProperties2 *convert_VkSparseImageFormatProperties2_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageFormatProperties232 *in, uint32_t count)
22670 {
22671     VkSparseImageFormatProperties2 *out;
22672     unsigned int i;
22673
22674     if (!in || !count) return NULL;
22675
22676     out = conversion_context_alloc(ctx, count * sizeof(*out));
22677     for (i = 0; i < count; i++)
22678     {
22679         convert_VkSparseImageFormatProperties2_win32_to_host(&in[i], &out[i]);
22680     }
22681
22682     return out;
22683 }
22684 #endif /* USE_STRUCT_CONVERSION */
22685
22686 #if defined(USE_STRUCT_CONVERSION)
22687 static inline void convert_VkSparseImageFormatProperties2_array_host_to_win32(const VkSparseImageFormatProperties2 *in, VkSparseImageFormatProperties232 *out, uint32_t count)
22688 {
22689     unsigned int i;
22690
22691     if (!in) return;
22692
22693     for (i = 0; i < count; i++)
22694     {
22695         convert_VkSparseImageFormatProperties2_host_to_win32(&in[i], &out[i]);
22696     }
22697 }
22698 #endif /* USE_STRUCT_CONVERSION */
22699
22700 #if defined(USE_STRUCT_CONVERSION)
22701 static inline void convert_VkFramebufferMixedSamplesCombinationNV_win32_to_host(const VkFramebufferMixedSamplesCombinationNV32 *in, VkFramebufferMixedSamplesCombinationNV *out)
22702 {
22703     if (!in) return;
22704
22705     out->sType = in->sType;
22706     out->pNext = in->pNext;
22707 }
22708 #endif /* USE_STRUCT_CONVERSION */
22709
22710 #if defined(USE_STRUCT_CONVERSION)
22711 static inline void convert_VkFramebufferMixedSamplesCombinationNV_host_to_win32(const VkFramebufferMixedSamplesCombinationNV *in, VkFramebufferMixedSamplesCombinationNV32 *out)
22712 {
22713     if (!in) return;
22714
22715     out->coverageReductionMode = in->coverageReductionMode;
22716     out->rasterizationSamples = in->rasterizationSamples;
22717     out->depthStencilSamples = in->depthStencilSamples;
22718     out->colorSamples = in->colorSamples;
22719 }
22720 #endif /* USE_STRUCT_CONVERSION */
22721
22722 #if defined(USE_STRUCT_CONVERSION)
22723 static inline VkFramebufferMixedSamplesCombinationNV *convert_VkFramebufferMixedSamplesCombinationNV_array_win32_to_host(struct conversion_context *ctx, const VkFramebufferMixedSamplesCombinationNV32 *in, uint32_t count)
22724 {
22725     VkFramebufferMixedSamplesCombinationNV *out;
22726     unsigned int i;
22727
22728     if (!in || !count) return NULL;
22729
22730     out = conversion_context_alloc(ctx, count * sizeof(*out));
22731     for (i = 0; i < count; i++)
22732     {
22733         convert_VkFramebufferMixedSamplesCombinationNV_win32_to_host(&in[i], &out[i]);
22734     }
22735
22736     return out;
22737 }
22738 #endif /* USE_STRUCT_CONVERSION */
22739
22740 #if defined(USE_STRUCT_CONVERSION)
22741 static inline void convert_VkFramebufferMixedSamplesCombinationNV_array_host_to_win32(const VkFramebufferMixedSamplesCombinationNV *in, VkFramebufferMixedSamplesCombinationNV32 *out, uint32_t count)
22742 {
22743     unsigned int i;
22744
22745     if (!in) return;
22746
22747     for (i = 0; i < count; i++)
22748     {
22749         convert_VkFramebufferMixedSamplesCombinationNV_host_to_win32(&in[i], &out[i]);
22750     }
22751 }
22752 #endif /* USE_STRUCT_CONVERSION */
22753
22754 #if defined(USE_STRUCT_CONVERSION)
22755 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_host(const VkPhysicalDeviceSurfaceInfo2KHR32 *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
22756 {
22757     if (!in) return;
22758
22759     out->sType = in->sType;
22760     out->pNext = in->pNext;
22761     out->surface = in->surface;
22762 }
22763 #endif /* USE_STRUCT_CONVERSION */
22764
22765 #if defined(USE_STRUCT_CONVERSION)
22766 static inline void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conversion_context *ctx, const VkSurfaceCapabilities2KHR32 *in, VkSurfaceCapabilities2KHR *out)
22767 {
22768     const VkBaseInStructure *in_header;
22769     VkBaseOutStructure *out_header = (void *)out;
22770
22771     if (!in) return;
22772
22773     out->sType = in->sType;
22774     out->pNext = NULL;
22775
22776     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
22777     {
22778         switch (in_header->sType)
22779         {
22780         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
22781         {
22782             VkSurfaceCapabilitiesPresentBarrierNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22783             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV;
22784             out_ext->pNext = NULL;
22785             out_header->pNext = (void *)out_ext;
22786             out_header = (void *)out_ext;
22787             break;
22788         }
22789         default:
22790             FIXME("Unhandled sType %u.", in_header->sType);
22791             break;
22792         }
22793     }
22794 }
22795 #endif /* USE_STRUCT_CONVERSION */
22796
22797 #if defined(USE_STRUCT_CONVERSION)
22798 static inline void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfaceCapabilities2KHR *in, VkSurfaceCapabilities2KHR32 *out)
22799 {
22800     const VkBaseInStructure *in_header;
22801     VkBaseOutStructure *out_header = (void *)out;
22802
22803     if (!in) return;
22804
22805     out->surfaceCapabilities = in->surfaceCapabilities;
22806
22807     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
22808     {
22809         switch (in_header->sType)
22810         {
22811         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
22812         {
22813             VkSurfaceCapabilitiesPresentBarrierNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV);
22814             const VkSurfaceCapabilitiesPresentBarrierNV *in_ext = (const VkSurfaceCapabilitiesPresentBarrierNV *)in_header;
22815             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV;
22816             out_ext->presentBarrierSupported = in_ext->presentBarrierSupported;
22817             out_header = (void *)out_ext;
22818             break;
22819         }
22820         default:
22821             break;
22822         }
22823     }
22824 }
22825 #endif /* USE_STRUCT_CONVERSION */
22826
22827 #if !defined(USE_STRUCT_CONVERSION)
22828 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win64_to_host(const VkPhysicalDeviceSurfaceInfo2KHR *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
22829 {
22830     if (!in) return;
22831
22832     out->sType = in->sType;
22833     out->pNext = in->pNext;
22834     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
22835 }
22836 #endif /* USE_STRUCT_CONVERSION */
22837
22838 #if defined(USE_STRUCT_CONVERSION)
22839 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_host(const VkPhysicalDeviceSurfaceInfo2KHR32 *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
22840 {
22841     if (!in) return;
22842
22843     out->sType = in->sType;
22844     out->pNext = in->pNext;
22845     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
22846 }
22847 #endif /* USE_STRUCT_CONVERSION */
22848
22849 #if defined(USE_STRUCT_CONVERSION)
22850 static inline void convert_VkSurfaceFormat2KHR_win32_to_host(struct conversion_context *ctx, const VkSurfaceFormat2KHR32 *in, VkSurfaceFormat2KHR *out)
22851 {
22852     const VkBaseInStructure *in_header;
22853     VkBaseOutStructure *out_header = (void *)out;
22854
22855     if (!in) return;
22856
22857     out->sType = in->sType;
22858     out->pNext = NULL;
22859
22860     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
22861     {
22862         switch (in_header->sType)
22863         {
22864         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
22865         {
22866             VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22867             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
22868             out_ext->pNext = NULL;
22869             out_header->pNext = (void *)out_ext;
22870             out_header = (void *)out_ext;
22871             break;
22872         }
22873         default:
22874             FIXME("Unhandled sType %u.", in_header->sType);
22875             break;
22876         }
22877     }
22878 }
22879 #endif /* USE_STRUCT_CONVERSION */
22880
22881 #if defined(USE_STRUCT_CONVERSION)
22882 static inline void convert_VkSurfaceFormat2KHR_host_to_win32(const VkSurfaceFormat2KHR *in, VkSurfaceFormat2KHR32 *out)
22883 {
22884     const VkBaseInStructure *in_header;
22885     VkBaseOutStructure *out_header = (void *)out;
22886
22887     if (!in) return;
22888
22889     out->surfaceFormat = in->surfaceFormat;
22890
22891     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
22892     {
22893         switch (in_header->sType)
22894         {
22895         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
22896         {
22897             VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT);
22898             const VkImageCompressionPropertiesEXT *in_ext = (const VkImageCompressionPropertiesEXT *)in_header;
22899             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
22900             out_ext->imageCompressionFlags = in_ext->imageCompressionFlags;
22901             out_ext->imageCompressionFixedRateFlags = in_ext->imageCompressionFixedRateFlags;
22902             out_header = (void *)out_ext;
22903             break;
22904         }
22905         default:
22906             break;
22907         }
22908     }
22909 }
22910 #endif /* USE_STRUCT_CONVERSION */
22911
22912 #if defined(USE_STRUCT_CONVERSION)
22913 static inline VkSurfaceFormat2KHR *convert_VkSurfaceFormat2KHR_array_win32_to_host(struct conversion_context *ctx, const VkSurfaceFormat2KHR32 *in, uint32_t count)
22914 {
22915     VkSurfaceFormat2KHR *out;
22916     unsigned int i;
22917
22918     if (!in || !count) return NULL;
22919
22920     out = conversion_context_alloc(ctx, count * sizeof(*out));
22921     for (i = 0; i < count; i++)
22922     {
22923         convert_VkSurfaceFormat2KHR_win32_to_host(ctx, &in[i], &out[i]);
22924     }
22925
22926     return out;
22927 }
22928 #endif /* USE_STRUCT_CONVERSION */
22929
22930 #if defined(USE_STRUCT_CONVERSION)
22931 static inline void convert_VkSurfaceFormat2KHR_array_host_to_win32(const VkSurfaceFormat2KHR *in, VkSurfaceFormat2KHR32 *out, uint32_t count)
22932 {
22933     unsigned int i;
22934
22935     if (!in) return;
22936
22937     for (i = 0; i < count; i++)
22938     {
22939         convert_VkSurfaceFormat2KHR_host_to_win32(&in[i], &out[i]);
22940     }
22941 }
22942 #endif /* USE_STRUCT_CONVERSION */
22943
22944 #if defined(USE_STRUCT_CONVERSION)
22945 static inline void convert_VkPhysicalDeviceToolProperties_win32_to_host(const VkPhysicalDeviceToolProperties32 *in, VkPhysicalDeviceToolProperties *out)
22946 {
22947     if (!in) return;
22948
22949     out->sType = in->sType;
22950     out->pNext = in->pNext;
22951 }
22952 #endif /* USE_STRUCT_CONVERSION */
22953
22954 #if defined(USE_STRUCT_CONVERSION)
22955 static inline void convert_VkPhysicalDeviceToolProperties_host_to_win32(const VkPhysicalDeviceToolProperties *in, VkPhysicalDeviceToolProperties32 *out)
22956 {
22957     if (!in) return;
22958
22959     memcpy(out->name, in->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
22960     memcpy(out->version, in->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
22961     out->purposes = in->purposes;
22962     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
22963     memcpy(out->layer, in->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
22964 }
22965 #endif /* USE_STRUCT_CONVERSION */
22966
22967 #if defined(USE_STRUCT_CONVERSION)
22968 static inline VkPhysicalDeviceToolProperties *convert_VkPhysicalDeviceToolProperties_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceToolProperties32 *in, uint32_t count)
22969 {
22970     VkPhysicalDeviceToolProperties *out;
22971     unsigned int i;
22972
22973     if (!in || !count) return NULL;
22974
22975     out = conversion_context_alloc(ctx, count * sizeof(*out));
22976     for (i = 0; i < count; i++)
22977     {
22978         convert_VkPhysicalDeviceToolProperties_win32_to_host(&in[i], &out[i]);
22979     }
22980
22981     return out;
22982 }
22983 #endif /* USE_STRUCT_CONVERSION */
22984
22985 #if defined(USE_STRUCT_CONVERSION)
22986 static inline void convert_VkPhysicalDeviceToolProperties_array_host_to_win32(const VkPhysicalDeviceToolProperties *in, VkPhysicalDeviceToolProperties32 *out, uint32_t count)
22987 {
22988     unsigned int i;
22989
22990     if (!in) return;
22991
22992     for (i = 0; i < count; i++)
22993     {
22994         convert_VkPhysicalDeviceToolProperties_host_to_win32(&in[i], &out[i]);
22995     }
22996 }
22997 #endif /* USE_STRUCT_CONVERSION */
22998
22999 #if defined(USE_STRUCT_CONVERSION)
23000 static inline void convert_VkPipelineExecutableInfoKHR_win32_to_host(const VkPipelineExecutableInfoKHR32 *in, VkPipelineExecutableInfoKHR *out)
23001 {
23002     if (!in) return;
23003
23004     out->sType = in->sType;
23005     out->pNext = in->pNext;
23006     out->pipeline = in->pipeline;
23007     out->executableIndex = in->executableIndex;
23008 }
23009 #endif /* USE_STRUCT_CONVERSION */
23010
23011 #if defined(USE_STRUCT_CONVERSION)
23012 static inline void convert_VkPipelineExecutableInternalRepresentationKHR_win32_to_host(const VkPipelineExecutableInternalRepresentationKHR32 *in, VkPipelineExecutableInternalRepresentationKHR *out)
23013 {
23014     if (!in) return;
23015
23016     out->sType = in->sType;
23017     out->pNext = in->pNext;
23018 }
23019 #endif /* USE_STRUCT_CONVERSION */
23020
23021 #if defined(USE_STRUCT_CONVERSION)
23022 static inline void convert_VkPipelineExecutableInternalRepresentationKHR_host_to_win32(const VkPipelineExecutableInternalRepresentationKHR *in, VkPipelineExecutableInternalRepresentationKHR32 *out)
23023 {
23024     if (!in) return;
23025
23026     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
23027     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
23028     out->isText = in->isText;
23029     out->dataSize = in->dataSize;
23030     out->pData = in->pData;
23031 }
23032 #endif /* USE_STRUCT_CONVERSION */
23033
23034 #if defined(USE_STRUCT_CONVERSION)
23035 static inline VkPipelineExecutableInternalRepresentationKHR *convert_VkPipelineExecutableInternalRepresentationKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableInternalRepresentationKHR32 *in, uint32_t count)
23036 {
23037     VkPipelineExecutableInternalRepresentationKHR *out;
23038     unsigned int i;
23039
23040     if (!in || !count) return NULL;
23041
23042     out = conversion_context_alloc(ctx, count * sizeof(*out));
23043     for (i = 0; i < count; i++)
23044     {
23045         convert_VkPipelineExecutableInternalRepresentationKHR_win32_to_host(&in[i], &out[i]);
23046     }
23047
23048     return out;
23049 }
23050 #endif /* USE_STRUCT_CONVERSION */
23051
23052 #if defined(USE_STRUCT_CONVERSION)
23053 static inline void convert_VkPipelineExecutableInternalRepresentationKHR_array_host_to_win32(const VkPipelineExecutableInternalRepresentationKHR *in, VkPipelineExecutableInternalRepresentationKHR32 *out, uint32_t count)
23054 {
23055     unsigned int i;
23056
23057     if (!in) return;
23058
23059     for (i = 0; i < count; i++)
23060     {
23061         convert_VkPipelineExecutableInternalRepresentationKHR_host_to_win32(&in[i], &out[i]);
23062     }
23063 }
23064 #endif /* USE_STRUCT_CONVERSION */
23065
23066 #if defined(USE_STRUCT_CONVERSION)
23067 static inline void convert_VkPipelineInfoKHR_win32_to_host(const VkPipelineInfoKHR32 *in, VkPipelineInfoKHR *out)
23068 {
23069     if (!in) return;
23070
23071     out->sType = in->sType;
23072     out->pNext = in->pNext;
23073     out->pipeline = in->pipeline;
23074 }
23075 #endif /* USE_STRUCT_CONVERSION */
23076
23077 #if defined(USE_STRUCT_CONVERSION)
23078 static inline void convert_VkPipelineExecutablePropertiesKHR_win32_to_host(const VkPipelineExecutablePropertiesKHR32 *in, VkPipelineExecutablePropertiesKHR *out)
23079 {
23080     if (!in) return;
23081
23082     out->sType = in->sType;
23083     out->pNext = in->pNext;
23084 }
23085 #endif /* USE_STRUCT_CONVERSION */
23086
23087 #if defined(USE_STRUCT_CONVERSION)
23088 static inline void convert_VkPipelineExecutablePropertiesKHR_host_to_win32(const VkPipelineExecutablePropertiesKHR *in, VkPipelineExecutablePropertiesKHR32 *out)
23089 {
23090     if (!in) return;
23091
23092     out->stages = in->stages;
23093     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
23094     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
23095     out->subgroupSize = in->subgroupSize;
23096 }
23097 #endif /* USE_STRUCT_CONVERSION */
23098
23099 #if defined(USE_STRUCT_CONVERSION)
23100 static inline VkPipelineExecutablePropertiesKHR *convert_VkPipelineExecutablePropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutablePropertiesKHR32 *in, uint32_t count)
23101 {
23102     VkPipelineExecutablePropertiesKHR *out;
23103     unsigned int i;
23104
23105     if (!in || !count) return NULL;
23106
23107     out = conversion_context_alloc(ctx, count * sizeof(*out));
23108     for (i = 0; i < count; i++)
23109     {
23110         convert_VkPipelineExecutablePropertiesKHR_win32_to_host(&in[i], &out[i]);
23111     }
23112
23113     return out;
23114 }
23115 #endif /* USE_STRUCT_CONVERSION */
23116
23117 #if defined(USE_STRUCT_CONVERSION)
23118 static inline void convert_VkPipelineExecutablePropertiesKHR_array_host_to_win32(const VkPipelineExecutablePropertiesKHR *in, VkPipelineExecutablePropertiesKHR32 *out, uint32_t count)
23119 {
23120     unsigned int i;
23121
23122     if (!in) return;
23123
23124     for (i = 0; i < count; i++)
23125     {
23126         convert_VkPipelineExecutablePropertiesKHR_host_to_win32(&in[i], &out[i]);
23127     }
23128 }
23129 #endif /* USE_STRUCT_CONVERSION */
23130
23131 #if defined(USE_STRUCT_CONVERSION)
23132 static inline void convert_VkPipelineExecutableStatisticKHR_win32_to_host(const VkPipelineExecutableStatisticKHR32 *in, VkPipelineExecutableStatisticKHR *out)
23133 {
23134     if (!in) return;
23135
23136     out->sType = in->sType;
23137     out->pNext = in->pNext;
23138 }
23139 #endif /* USE_STRUCT_CONVERSION */
23140
23141 #if defined(USE_STRUCT_CONVERSION)
23142 static inline void convert_VkPipelineExecutableStatisticKHR_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out)
23143 {
23144     if (!in) return;
23145
23146     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
23147     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
23148     out->format = in->format;
23149     out->value = in->value;
23150 }
23151 #endif /* USE_STRUCT_CONVERSION */
23152
23153 #if defined(USE_STRUCT_CONVERSION)
23154 static inline VkPipelineExecutableStatisticKHR *convert_VkPipelineExecutableStatisticKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableStatisticKHR32 *in, uint32_t count)
23155 {
23156     VkPipelineExecutableStatisticKHR *out;
23157     unsigned int i;
23158
23159     if (!in || !count) return NULL;
23160
23161     out = conversion_context_alloc(ctx, count * sizeof(*out));
23162     for (i = 0; i < count; i++)
23163     {
23164         convert_VkPipelineExecutableStatisticKHR_win32_to_host(&in[i], &out[i]);
23165     }
23166
23167     return out;
23168 }
23169 #endif /* USE_STRUCT_CONVERSION */
23170
23171 #if defined(USE_STRUCT_CONVERSION)
23172 static inline void convert_VkPipelineExecutableStatisticKHR_array_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out, uint32_t count)
23173 {
23174     unsigned int i;
23175
23176     if (!in) return;
23177
23178     for (i = 0; i < count; i++)
23179     {
23180         convert_VkPipelineExecutableStatisticKHR_host_to_win32(&in[i], &out[i]);
23181     }
23182 }
23183 #endif /* USE_STRUCT_CONVERSION */
23184
23185 #if defined(USE_STRUCT_CONVERSION)
23186 static inline void convert_VkPipelineInfoEXT_win32_to_host(const VkPipelineInfoEXT32 *in, VkPipelineInfoEXT *out)
23187 {
23188     if (!in) return;
23189
23190     out->sType = in->sType;
23191     out->pNext = in->pNext;
23192     out->pipeline = in->pipeline;
23193 }
23194 #endif /* USE_STRUCT_CONVERSION */
23195
23196 #if defined(USE_STRUCT_CONVERSION)
23197 static inline void convert_VkCheckpointData2NV_win32_to_host(const VkCheckpointData2NV32 *in, VkCheckpointData2NV *out)
23198 {
23199     if (!in) return;
23200
23201     out->sType = in->sType;
23202     out->pNext = in->pNext;
23203 }
23204 #endif /* USE_STRUCT_CONVERSION */
23205
23206 #if defined(USE_STRUCT_CONVERSION)
23207 static inline void convert_VkCheckpointData2NV_host_to_win32(const VkCheckpointData2NV *in, VkCheckpointData2NV32 *out)
23208 {
23209     if (!in) return;
23210
23211     out->stage = in->stage;
23212     out->pCheckpointMarker = in->pCheckpointMarker;
23213 }
23214 #endif /* USE_STRUCT_CONVERSION */
23215
23216 #if defined(USE_STRUCT_CONVERSION)
23217 static inline VkCheckpointData2NV *convert_VkCheckpointData2NV_array_win32_to_host(struct conversion_context *ctx, const VkCheckpointData2NV32 *in, uint32_t count)
23218 {
23219     VkCheckpointData2NV *out;
23220     unsigned int i;
23221
23222     if (!in || !count) return NULL;
23223
23224     out = conversion_context_alloc(ctx, count * sizeof(*out));
23225     for (i = 0; i < count; i++)
23226     {
23227         convert_VkCheckpointData2NV_win32_to_host(&in[i], &out[i]);
23228     }
23229
23230     return out;
23231 }
23232 #endif /* USE_STRUCT_CONVERSION */
23233
23234 #if defined(USE_STRUCT_CONVERSION)
23235 static inline void convert_VkCheckpointData2NV_array_host_to_win32(const VkCheckpointData2NV *in, VkCheckpointData2NV32 *out, uint32_t count)
23236 {
23237     unsigned int i;
23238
23239     if (!in) return;
23240
23241     for (i = 0; i < count; i++)
23242     {
23243         convert_VkCheckpointData2NV_host_to_win32(&in[i], &out[i]);
23244     }
23245 }
23246 #endif /* USE_STRUCT_CONVERSION */
23247
23248 #if defined(USE_STRUCT_CONVERSION)
23249 static inline void convert_VkCheckpointDataNV_win32_to_host(const VkCheckpointDataNV32 *in, VkCheckpointDataNV *out)
23250 {
23251     if (!in) return;
23252
23253     out->sType = in->sType;
23254     out->pNext = in->pNext;
23255 }
23256 #endif /* USE_STRUCT_CONVERSION */
23257
23258 #if defined(USE_STRUCT_CONVERSION)
23259 static inline void convert_VkCheckpointDataNV_host_to_win32(const VkCheckpointDataNV *in, VkCheckpointDataNV32 *out)
23260 {
23261     if (!in) return;
23262
23263     out->stage = in->stage;
23264     out->pCheckpointMarker = in->pCheckpointMarker;
23265 }
23266 #endif /* USE_STRUCT_CONVERSION */
23267
23268 #if defined(USE_STRUCT_CONVERSION)
23269 static inline VkCheckpointDataNV *convert_VkCheckpointDataNV_array_win32_to_host(struct conversion_context *ctx, const VkCheckpointDataNV32 *in, uint32_t count)
23270 {
23271     VkCheckpointDataNV *out;
23272     unsigned int i;
23273
23274     if (!in || !count) return NULL;
23275
23276     out = conversion_context_alloc(ctx, count * sizeof(*out));
23277     for (i = 0; i < count; i++)
23278     {
23279         convert_VkCheckpointDataNV_win32_to_host(&in[i], &out[i]);
23280     }
23281
23282     return out;
23283 }
23284 #endif /* USE_STRUCT_CONVERSION */
23285
23286 #if defined(USE_STRUCT_CONVERSION)
23287 static inline void convert_VkCheckpointDataNV_array_host_to_win32(const VkCheckpointDataNV *in, VkCheckpointDataNV32 *out, uint32_t count)
23288 {
23289     unsigned int i;
23290
23291     if (!in) return;
23292
23293     for (i = 0; i < count; i++)
23294     {
23295         convert_VkCheckpointDataNV_host_to_win32(&in[i], &out[i]);
23296     }
23297 }
23298 #endif /* USE_STRUCT_CONVERSION */
23299
23300 #if defined(USE_STRUCT_CONVERSION)
23301 static inline void convert_VkShaderModuleIdentifierEXT_win32_to_host(const VkShaderModuleIdentifierEXT32 *in, VkShaderModuleIdentifierEXT *out)
23302 {
23303     if (!in) return;
23304
23305     out->sType = in->sType;
23306     out->pNext = in->pNext;
23307 }
23308 #endif /* USE_STRUCT_CONVERSION */
23309
23310 #if defined(USE_STRUCT_CONVERSION)
23311 static inline void convert_VkShaderModuleIdentifierEXT_host_to_win32(const VkShaderModuleIdentifierEXT *in, VkShaderModuleIdentifierEXT32 *out)
23312 {
23313     if (!in) return;
23314
23315     out->identifierSize = in->identifierSize;
23316     memcpy(out->identifier, in->identifier, VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT * sizeof(uint8_t));
23317 }
23318 #endif /* USE_STRUCT_CONVERSION */
23319
23320 #if defined(USE_STRUCT_CONVERSION)
23321 static inline void convert_VkInitializePerformanceApiInfoINTEL_win32_to_host(const VkInitializePerformanceApiInfoINTEL32 *in, VkInitializePerformanceApiInfoINTEL *out)
23322 {
23323     if (!in) return;
23324
23325     out->sType = in->sType;
23326     out->pNext = in->pNext;
23327     out->pUserData = in->pUserData;
23328 }
23329 #endif /* USE_STRUCT_CONVERSION */
23330
23331 #if defined(USE_STRUCT_CONVERSION)
23332 static inline void convert_VkSparseMemoryBind_win32_to_host(const VkSparseMemoryBind32 *in, VkSparseMemoryBind *out)
23333 {
23334     if (!in) return;
23335
23336     out->resourceOffset = in->resourceOffset;
23337     out->size = in->size;
23338     out->memory = in->memory;
23339     out->memoryOffset = in->memoryOffset;
23340     out->flags = in->flags;
23341 }
23342 #endif /* USE_STRUCT_CONVERSION */
23343
23344 #if defined(USE_STRUCT_CONVERSION)
23345 static inline const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseMemoryBind32 *in, uint32_t count)
23346 {
23347     VkSparseMemoryBind *out;
23348     unsigned int i;
23349
23350     if (!in || !count) return NULL;
23351
23352     out = conversion_context_alloc(ctx, count * sizeof(*out));
23353     for (i = 0; i < count; i++)
23354     {
23355         convert_VkSparseMemoryBind_win32_to_host(&in[i], &out[i]);
23356     }
23357
23358     return out;
23359 }
23360 #endif /* USE_STRUCT_CONVERSION */
23361
23362 #if defined(USE_STRUCT_CONVERSION)
23363 static inline void convert_VkSparseBufferMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, VkSparseBufferMemoryBindInfo *out)
23364 {
23365     if (!in) return;
23366
23367     out->buffer = in->buffer;
23368     out->bindCount = in->bindCount;
23369     out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, in->pBinds, in->bindCount);
23370 }
23371 #endif /* USE_STRUCT_CONVERSION */
23372
23373 #if defined(USE_STRUCT_CONVERSION)
23374 static inline const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, uint32_t count)
23375 {
23376     VkSparseBufferMemoryBindInfo *out;
23377     unsigned int i;
23378
23379     if (!in || !count) return NULL;
23380
23381     out = conversion_context_alloc(ctx, count * sizeof(*out));
23382     for (i = 0; i < count; i++)
23383     {
23384         convert_VkSparseBufferMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
23385     }
23386
23387     return out;
23388 }
23389 #endif /* USE_STRUCT_CONVERSION */
23390
23391 #if defined(USE_STRUCT_CONVERSION)
23392 static inline void convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, VkSparseImageOpaqueMemoryBindInfo *out)
23393 {
23394     if (!in) return;
23395
23396     out->image = in->image;
23397     out->bindCount = in->bindCount;
23398     out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, in->pBinds, in->bindCount);
23399 }
23400 #endif /* USE_STRUCT_CONVERSION */
23401
23402 #if defined(USE_STRUCT_CONVERSION)
23403 static inline const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, uint32_t count)
23404 {
23405     VkSparseImageOpaqueMemoryBindInfo *out;
23406     unsigned int i;
23407
23408     if (!in || !count) return NULL;
23409
23410     out = conversion_context_alloc(ctx, count * sizeof(*out));
23411     for (i = 0; i < count; i++)
23412     {
23413         convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
23414     }
23415
23416     return out;
23417 }
23418 #endif /* USE_STRUCT_CONVERSION */
23419
23420 #if defined(USE_STRUCT_CONVERSION)
23421 static inline void convert_VkSparseImageMemoryBind_win32_to_host(const VkSparseImageMemoryBind32 *in, VkSparseImageMemoryBind *out)
23422 {
23423     if (!in) return;
23424
23425     out->subresource = in->subresource;
23426     out->offset = in->offset;
23427     out->extent = in->extent;
23428     out->memory = in->memory;
23429     out->memoryOffset = in->memoryOffset;
23430     out->flags = in->flags;
23431 }
23432 #endif /* USE_STRUCT_CONVERSION */
23433
23434 #if defined(USE_STRUCT_CONVERSION)
23435 static inline const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBind32 *in, uint32_t count)
23436 {
23437     VkSparseImageMemoryBind *out;
23438     unsigned int i;
23439
23440     if (!in || !count) return NULL;
23441
23442     out = conversion_context_alloc(ctx, count * sizeof(*out));
23443     for (i = 0; i < count; i++)
23444     {
23445         convert_VkSparseImageMemoryBind_win32_to_host(&in[i], &out[i]);
23446     }
23447
23448     return out;
23449 }
23450 #endif /* USE_STRUCT_CONVERSION */
23451
23452 #if defined(USE_STRUCT_CONVERSION)
23453 static inline void convert_VkSparseImageMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, VkSparseImageMemoryBindInfo *out)
23454 {
23455     if (!in) return;
23456
23457     out->image = in->image;
23458     out->bindCount = in->bindCount;
23459     out->pBinds = convert_VkSparseImageMemoryBind_array_win32_to_host(ctx, in->pBinds, in->bindCount);
23460 }
23461 #endif /* USE_STRUCT_CONVERSION */
23462
23463 #if defined(USE_STRUCT_CONVERSION)
23464 static inline const VkSparseImageMemoryBindInfo *convert_VkSparseImageMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, uint32_t count)
23465 {
23466     VkSparseImageMemoryBindInfo *out;
23467     unsigned int i;
23468
23469     if (!in || !count) return NULL;
23470
23471     out = conversion_context_alloc(ctx, count * sizeof(*out));
23472     for (i = 0; i < count; i++)
23473     {
23474         convert_VkSparseImageMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
23475     }
23476
23477     return out;
23478 }
23479 #endif /* USE_STRUCT_CONVERSION */
23480
23481 #if defined(USE_STRUCT_CONVERSION)
23482 static inline void convert_VkBindSparseInfo_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, VkBindSparseInfo *out)
23483 {
23484     const VkBaseInStructure *in_header;
23485     VkBaseOutStructure *out_header = (void *)out;
23486
23487     if (!in) return;
23488
23489     out->sType = in->sType;
23490     out->pNext = NULL;
23491     out->waitSemaphoreCount = in->waitSemaphoreCount;
23492     out->pWaitSemaphores = in->pWaitSemaphores;
23493     out->bufferBindCount = in->bufferBindCount;
23494     out->pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(ctx, in->pBufferBinds, in->bufferBindCount);
23495     out->imageOpaqueBindCount = in->imageOpaqueBindCount;
23496     out->pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(ctx, in->pImageOpaqueBinds, in->imageOpaqueBindCount);
23497     out->imageBindCount = in->imageBindCount;
23498     out->pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win32_to_host(ctx, in->pImageBinds, in->imageBindCount);
23499     out->signalSemaphoreCount = in->signalSemaphoreCount;
23500     out->pSignalSemaphores = in->pSignalSemaphores;
23501
23502     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
23503     {
23504         switch (in_header->sType)
23505         {
23506         case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
23507         {
23508             VkDeviceGroupBindSparseInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23509             const VkDeviceGroupBindSparseInfo32 *in_ext = (const VkDeviceGroupBindSparseInfo32 *)in_header;
23510             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO;
23511             out_ext->pNext = NULL;
23512             out_ext->resourceDeviceIndex = in_ext->resourceDeviceIndex;
23513             out_ext->memoryDeviceIndex = in_ext->memoryDeviceIndex;
23514             out_header->pNext = (void *)out_ext;
23515             out_header = (void *)out_ext;
23516             break;
23517         }
23518         case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
23519         {
23520             VkTimelineSemaphoreSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23521             const VkTimelineSemaphoreSubmitInfo32 *in_ext = (const VkTimelineSemaphoreSubmitInfo32 *)in_header;
23522             out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
23523             out_ext->pNext = NULL;
23524             out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount;
23525             out_ext->pWaitSemaphoreValues = in_ext->pWaitSemaphoreValues;
23526             out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount;
23527             out_ext->pSignalSemaphoreValues = in_ext->pSignalSemaphoreValues;
23528             out_header->pNext = (void *)out_ext;
23529             out_header = (void *)out_ext;
23530             break;
23531         }
23532         default:
23533             FIXME("Unhandled sType %u.", in_header->sType);
23534             break;
23535         }
23536     }
23537 }
23538 #endif /* USE_STRUCT_CONVERSION */
23539
23540 #if defined(USE_STRUCT_CONVERSION)
23541 static inline const VkBindSparseInfo *convert_VkBindSparseInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, uint32_t count)
23542 {
23543     VkBindSparseInfo *out;
23544     unsigned int i;
23545
23546     if (!in || !count) return NULL;
23547
23548     out = conversion_context_alloc(ctx, count * sizeof(*out));
23549     for (i = 0; i < count; i++)
23550     {
23551         convert_VkBindSparseInfo_win32_to_host(ctx, &in[i], &out[i]);
23552     }
23553
23554     return out;
23555 }
23556 #endif /* USE_STRUCT_CONVERSION */
23557
23558 #if defined(USE_STRUCT_CONVERSION)
23559 static inline void convert_VkPresentInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPresentInfoKHR32 *in, VkPresentInfoKHR *out)
23560 {
23561     const VkBaseInStructure *in_header;
23562     VkBaseOutStructure *out_header = (void *)out;
23563
23564     if (!in) return;
23565
23566     out->sType = in->sType;
23567     out->pNext = NULL;
23568     out->waitSemaphoreCount = in->waitSemaphoreCount;
23569     out->pWaitSemaphores = in->pWaitSemaphores;
23570     out->swapchainCount = in->swapchainCount;
23571     out->pSwapchains = in->pSwapchains;
23572     out->pImageIndices = in->pImageIndices;
23573     out->pResults = in->pResults;
23574
23575     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
23576     {
23577         switch (in_header->sType)
23578         {
23579         case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
23580         {
23581             VkPresentRegionsKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23582             const VkPresentRegionsKHR32 *in_ext = (const VkPresentRegionsKHR32 *)in_header;
23583             out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR;
23584             out_ext->pNext = NULL;
23585             out_ext->swapchainCount = in_ext->swapchainCount;
23586             out_ext->pRegions = in_ext->pRegions;
23587             out_header->pNext = (void *)out_ext;
23588             out_header = (void *)out_ext;
23589             break;
23590         }
23591         case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
23592         {
23593             VkDeviceGroupPresentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23594             const VkDeviceGroupPresentInfoKHR32 *in_ext = (const VkDeviceGroupPresentInfoKHR32 *)in_header;
23595             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR;
23596             out_ext->pNext = NULL;
23597             out_ext->swapchainCount = in_ext->swapchainCount;
23598             out_ext->pDeviceMasks = in_ext->pDeviceMasks;
23599             out_ext->mode = in_ext->mode;
23600             out_header->pNext = (void *)out_ext;
23601             out_header = (void *)out_ext;
23602             break;
23603         }
23604         case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
23605         {
23606             VkPresentIdKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23607             const VkPresentIdKHR32 *in_ext = (const VkPresentIdKHR32 *)in_header;
23608             out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_ID_KHR;
23609             out_ext->pNext = NULL;
23610             out_ext->swapchainCount = in_ext->swapchainCount;
23611             out_ext->pPresentIds = in_ext->pPresentIds;
23612             out_header->pNext = (void *)out_ext;
23613             out_header = (void *)out_ext;
23614             break;
23615         }
23616         default:
23617             FIXME("Unhandled sType %u.", in_header->sType);
23618             break;
23619         }
23620     }
23621 }
23622 #endif /* USE_STRUCT_CONVERSION */
23623
23624 #if !defined(USE_STRUCT_CONVERSION)
23625 static inline void convert_VkSubmitInfo_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, VkSubmitInfo *out)
23626 {
23627     if (!in) return;
23628
23629     out->sType = in->sType;
23630     out->pNext = in->pNext;
23631     out->waitSemaphoreCount = in->waitSemaphoreCount;
23632     out->pWaitSemaphores = in->pWaitSemaphores;
23633     out->pWaitDstStageMask = in->pWaitDstStageMask;
23634     out->commandBufferCount = in->commandBufferCount;
23635     out->pCommandBuffers = convert_VkCommandBuffer_array_win64_to_host(ctx, in->pCommandBuffers, in->commandBufferCount);
23636     out->signalSemaphoreCount = in->signalSemaphoreCount;
23637     out->pSignalSemaphores = in->pSignalSemaphores;
23638 }
23639 #endif /* USE_STRUCT_CONVERSION */
23640
23641 #if defined(USE_STRUCT_CONVERSION)
23642 static inline void convert_VkSubmitInfo_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo32 *in, VkSubmitInfo *out)
23643 {
23644     const VkBaseInStructure *in_header;
23645     VkBaseOutStructure *out_header = (void *)out;
23646
23647     if (!in) return;
23648
23649     out->sType = in->sType;
23650     out->pNext = NULL;
23651     out->waitSemaphoreCount = in->waitSemaphoreCount;
23652     out->pWaitSemaphores = in->pWaitSemaphores;
23653     out->pWaitDstStageMask = in->pWaitDstStageMask;
23654     out->commandBufferCount = in->commandBufferCount;
23655     out->pCommandBuffers = convert_VkCommandBuffer_array_win32_to_host(ctx, in->pCommandBuffers, in->commandBufferCount);
23656     out->signalSemaphoreCount = in->signalSemaphoreCount;
23657     out->pSignalSemaphores = in->pSignalSemaphores;
23658
23659     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
23660     {
23661         switch (in_header->sType)
23662         {
23663         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
23664         {
23665             VkDeviceGroupSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23666             const VkDeviceGroupSubmitInfo32 *in_ext = (const VkDeviceGroupSubmitInfo32 *)in_header;
23667             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO;
23668             out_ext->pNext = NULL;
23669             out_ext->waitSemaphoreCount = in_ext->waitSemaphoreCount;
23670             out_ext->pWaitSemaphoreDeviceIndices = in_ext->pWaitSemaphoreDeviceIndices;
23671             out_ext->commandBufferCount = in_ext->commandBufferCount;
23672             out_ext->pCommandBufferDeviceMasks = in_ext->pCommandBufferDeviceMasks;
23673             out_ext->signalSemaphoreCount = in_ext->signalSemaphoreCount;
23674             out_ext->pSignalSemaphoreDeviceIndices = in_ext->pSignalSemaphoreDeviceIndices;
23675             out_header->pNext = (void *)out_ext;
23676             out_header = (void *)out_ext;
23677             break;
23678         }
23679         case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
23680         {
23681             VkProtectedSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23682             const VkProtectedSubmitInfo32 *in_ext = (const VkProtectedSubmitInfo32 *)in_header;
23683             out_ext->sType = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO;
23684             out_ext->pNext = NULL;
23685             out_ext->protectedSubmit = in_ext->protectedSubmit;
23686             out_header->pNext = (void *)out_ext;
23687             out_header = (void *)out_ext;
23688             break;
23689         }
23690         case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
23691         {
23692             VkTimelineSemaphoreSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23693             const VkTimelineSemaphoreSubmitInfo32 *in_ext = (const VkTimelineSemaphoreSubmitInfo32 *)in_header;
23694             out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
23695             out_ext->pNext = NULL;
23696             out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount;
23697             out_ext->pWaitSemaphoreValues = in_ext->pWaitSemaphoreValues;
23698             out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount;
23699             out_ext->pSignalSemaphoreValues = in_ext->pSignalSemaphoreValues;
23700             out_header->pNext = (void *)out_ext;
23701             out_header = (void *)out_ext;
23702             break;
23703         }
23704         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
23705         {
23706             VkPerformanceQuerySubmitInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23707             const VkPerformanceQuerySubmitInfoKHR32 *in_ext = (const VkPerformanceQuerySubmitInfoKHR32 *)in_header;
23708             out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR;
23709             out_ext->pNext = NULL;
23710             out_ext->counterPassIndex = in_ext->counterPassIndex;
23711             out_header->pNext = (void *)out_ext;
23712             out_header = (void *)out_ext;
23713             break;
23714         }
23715         default:
23716             FIXME("Unhandled sType %u.", in_header->sType);
23717             break;
23718         }
23719     }
23720 }
23721 #endif /* USE_STRUCT_CONVERSION */
23722
23723 #if !defined(USE_STRUCT_CONVERSION)
23724 static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, uint32_t count)
23725 {
23726     VkSubmitInfo *out;
23727     unsigned int i;
23728
23729     if (!in || !count) return NULL;
23730
23731     out = conversion_context_alloc(ctx, count * sizeof(*out));
23732     for (i = 0; i < count; i++)
23733     {
23734         convert_VkSubmitInfo_win64_to_host(ctx, &in[i], &out[i]);
23735     }
23736
23737     return out;
23738 }
23739 #endif /* USE_STRUCT_CONVERSION */
23740
23741 #if defined(USE_STRUCT_CONVERSION)
23742 static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo32 *in, uint32_t count)
23743 {
23744     VkSubmitInfo *out;
23745     unsigned int i;
23746
23747     if (!in || !count) return NULL;
23748
23749     out = conversion_context_alloc(ctx, count * sizeof(*out));
23750     for (i = 0; i < count; i++)
23751     {
23752         convert_VkSubmitInfo_win32_to_host(ctx, &in[i], &out[i]);
23753     }
23754
23755     return out;
23756 }
23757 #endif /* USE_STRUCT_CONVERSION */
23758
23759 #if defined(USE_STRUCT_CONVERSION)
23760 static inline void convert_VkSemaphoreSubmitInfo_win32_to_host(const VkSemaphoreSubmitInfo32 *in, VkSemaphoreSubmitInfo *out)
23761 {
23762     if (!in) return;
23763
23764     out->sType = in->sType;
23765     out->pNext = in->pNext;
23766     out->semaphore = in->semaphore;
23767     out->value = in->value;
23768     out->stageMask = in->stageMask;
23769     out->deviceIndex = in->deviceIndex;
23770 }
23771 #endif /* USE_STRUCT_CONVERSION */
23772
23773 #if defined(USE_STRUCT_CONVERSION)
23774 static inline const VkSemaphoreSubmitInfo *convert_VkSemaphoreSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSemaphoreSubmitInfo32 *in, uint32_t count)
23775 {
23776     VkSemaphoreSubmitInfo *out;
23777     unsigned int i;
23778
23779     if (!in || !count) return NULL;
23780
23781     out = conversion_context_alloc(ctx, count * sizeof(*out));
23782     for (i = 0; i < count; i++)
23783     {
23784         convert_VkSemaphoreSubmitInfo_win32_to_host(&in[i], &out[i]);
23785     }
23786
23787     return out;
23788 }
23789 #endif /* USE_STRUCT_CONVERSION */
23790
23791 #if !defined(USE_STRUCT_CONVERSION)
23792 static inline void convert_VkCommandBufferSubmitInfo_win64_to_host(const VkCommandBufferSubmitInfo *in, VkCommandBufferSubmitInfo *out)
23793 {
23794     if (!in) return;
23795
23796     out->sType = in->sType;
23797     out->pNext = in->pNext;
23798     out->commandBuffer = wine_cmd_buffer_from_handle(in->commandBuffer)->command_buffer;
23799     out->deviceMask = in->deviceMask;
23800 }
23801 #endif /* USE_STRUCT_CONVERSION */
23802
23803 #if defined(USE_STRUCT_CONVERSION)
23804 static inline void convert_VkCommandBufferSubmitInfo_win32_to_host(const VkCommandBufferSubmitInfo32 *in, VkCommandBufferSubmitInfo *out)
23805 {
23806     if (!in) return;
23807
23808     out->sType = in->sType;
23809     out->pNext = in->pNext;
23810     out->commandBuffer = wine_cmd_buffer_from_handle(in->commandBuffer)->command_buffer;
23811     out->deviceMask = in->deviceMask;
23812 }
23813 #endif /* USE_STRUCT_CONVERSION */
23814
23815 #if !defined(USE_STRUCT_CONVERSION)
23816 static inline const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo *in, uint32_t count)
23817 {
23818     VkCommandBufferSubmitInfo *out;
23819     unsigned int i;
23820
23821     if (!in || !count) return NULL;
23822
23823     out = conversion_context_alloc(ctx, count * sizeof(*out));
23824     for (i = 0; i < count; i++)
23825     {
23826         convert_VkCommandBufferSubmitInfo_win64_to_host(&in[i], &out[i]);
23827     }
23828
23829     return out;
23830 }
23831 #endif /* USE_STRUCT_CONVERSION */
23832
23833 #if defined(USE_STRUCT_CONVERSION)
23834 static inline const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo32 *in, uint32_t count)
23835 {
23836     VkCommandBufferSubmitInfo *out;
23837     unsigned int i;
23838
23839     if (!in || !count) return NULL;
23840
23841     out = conversion_context_alloc(ctx, count * sizeof(*out));
23842     for (i = 0; i < count; i++)
23843     {
23844         convert_VkCommandBufferSubmitInfo_win32_to_host(&in[i], &out[i]);
23845     }
23846
23847     return out;
23848 }
23849 #endif /* USE_STRUCT_CONVERSION */
23850
23851 #if !defined(USE_STRUCT_CONVERSION)
23852 static inline void convert_VkSubmitInfo2_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, VkSubmitInfo2 *out)
23853 {
23854     if (!in) return;
23855
23856     out->sType = in->sType;
23857     out->pNext = in->pNext;
23858     out->flags = in->flags;
23859     out->waitSemaphoreInfoCount = in->waitSemaphoreInfoCount;
23860     out->pWaitSemaphoreInfos = in->pWaitSemaphoreInfos;
23861     out->commandBufferInfoCount = in->commandBufferInfoCount;
23862     out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win64_to_host(ctx, in->pCommandBufferInfos, in->commandBufferInfoCount);
23863     out->signalSemaphoreInfoCount = in->signalSemaphoreInfoCount;
23864     out->pSignalSemaphoreInfos = in->pSignalSemaphoreInfos;
23865 }
23866 #endif /* USE_STRUCT_CONVERSION */
23867
23868 #if defined(USE_STRUCT_CONVERSION)
23869 static inline void convert_VkSubmitInfo2_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, VkSubmitInfo2 *out)
23870 {
23871     const VkBaseInStructure *in_header;
23872     VkBaseOutStructure *out_header = (void *)out;
23873
23874     if (!in) return;
23875
23876     out->sType = in->sType;
23877     out->pNext = NULL;
23878     out->flags = in->flags;
23879     out->waitSemaphoreInfoCount = in->waitSemaphoreInfoCount;
23880     out->pWaitSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, in->pWaitSemaphoreInfos, in->waitSemaphoreInfoCount);
23881     out->commandBufferInfoCount = in->commandBufferInfoCount;
23882     out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win32_to_host(ctx, in->pCommandBufferInfos, in->commandBufferInfoCount);
23883     out->signalSemaphoreInfoCount = in->signalSemaphoreInfoCount;
23884     out->pSignalSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, in->pSignalSemaphoreInfos, in->signalSemaphoreInfoCount);
23885
23886     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
23887     {
23888         switch (in_header->sType)
23889         {
23890         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
23891         {
23892             VkPerformanceQuerySubmitInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23893             const VkPerformanceQuerySubmitInfoKHR32 *in_ext = (const VkPerformanceQuerySubmitInfoKHR32 *)in_header;
23894             out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR;
23895             out_ext->pNext = NULL;
23896             out_ext->counterPassIndex = in_ext->counterPassIndex;
23897             out_header->pNext = (void *)out_ext;
23898             out_header = (void *)out_ext;
23899             break;
23900         }
23901         default:
23902             FIXME("Unhandled sType %u.", in_header->sType);
23903             break;
23904         }
23905     }
23906 }
23907 #endif /* USE_STRUCT_CONVERSION */
23908
23909 #if !defined(USE_STRUCT_CONVERSION)
23910 static inline const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, uint32_t count)
23911 {
23912     VkSubmitInfo2 *out;
23913     unsigned int i;
23914
23915     if (!in || !count) return NULL;
23916
23917     out = conversion_context_alloc(ctx, count * sizeof(*out));
23918     for (i = 0; i < count; i++)
23919     {
23920         convert_VkSubmitInfo2_win64_to_host(ctx, &in[i], &out[i]);
23921     }
23922
23923     return out;
23924 }
23925 #endif /* USE_STRUCT_CONVERSION */
23926
23927 #if defined(USE_STRUCT_CONVERSION)
23928 static inline const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, uint32_t count)
23929 {
23930     VkSubmitInfo2 *out;
23931     unsigned int i;
23932
23933     if (!in || !count) return NULL;
23934
23935     out = conversion_context_alloc(ctx, count * sizeof(*out));
23936     for (i = 0; i < count; i++)
23937     {
23938         convert_VkSubmitInfo2_win32_to_host(ctx, &in[i], &out[i]);
23939     }
23940
23941     return out;
23942 }
23943 #endif /* USE_STRUCT_CONVERSION */
23944
23945 #if !defined(USE_STRUCT_CONVERSION)
23946 static inline void convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(const VkDebugUtilsObjectNameInfoEXT *in, VkDebugUtilsObjectNameInfoEXT *out)
23947 {
23948     if (!in) return;
23949
23950     out->sType = in->sType;
23951     out->pNext = in->pNext;
23952     out->objectType = in->objectType;
23953     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
23954     out->pObjectName = in->pObjectName;
23955 }
23956 #endif /* USE_STRUCT_CONVERSION */
23957
23958 #if defined(USE_STRUCT_CONVERSION)
23959 static inline void convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(const VkDebugUtilsObjectNameInfoEXT32 *in, VkDebugUtilsObjectNameInfoEXT *out)
23960 {
23961     if (!in) return;
23962
23963     out->sType = in->sType;
23964     out->pNext = in->pNext;
23965     out->objectType = in->objectType;
23966     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
23967     out->pObjectName = in->pObjectName;
23968 }
23969 #endif /* USE_STRUCT_CONVERSION */
23970
23971 #if !defined(USE_STRUCT_CONVERSION)
23972 static inline void convert_VkDebugUtilsObjectTagInfoEXT_win64_to_host(const VkDebugUtilsObjectTagInfoEXT *in, VkDebugUtilsObjectTagInfoEXT *out)
23973 {
23974     if (!in) return;
23975
23976     out->sType = in->sType;
23977     out->pNext = in->pNext;
23978     out->objectType = in->objectType;
23979     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
23980     out->tagName = in->tagName;
23981     out->tagSize = in->tagSize;
23982     out->pTag = in->pTag;
23983 }
23984 #endif /* USE_STRUCT_CONVERSION */
23985
23986 #if defined(USE_STRUCT_CONVERSION)
23987 static inline void convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host(const VkDebugUtilsObjectTagInfoEXT32 *in, VkDebugUtilsObjectTagInfoEXT *out)
23988 {
23989     if (!in) return;
23990
23991     out->sType = in->sType;
23992     out->pNext = in->pNext;
23993     out->objectType = in->objectType;
23994     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
23995     out->tagName = in->tagName;
23996     out->tagSize = in->tagSize;
23997     out->pTag = in->pTag;
23998 }
23999 #endif /* USE_STRUCT_CONVERSION */
24000
24001 #if defined(USE_STRUCT_CONVERSION)
24002 static inline void convert_VkSemaphoreSignalInfo_win32_to_host(const VkSemaphoreSignalInfo32 *in, VkSemaphoreSignalInfo *out)
24003 {
24004     if (!in) return;
24005
24006     out->sType = in->sType;
24007     out->pNext = in->pNext;
24008     out->semaphore = in->semaphore;
24009     out->value = in->value;
24010 }
24011 #endif /* USE_STRUCT_CONVERSION */
24012
24013 #if defined(USE_STRUCT_CONVERSION)
24014 static inline const VkDebugUtilsLabelEXT *convert_VkDebugUtilsLabelEXT_array_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsLabelEXT32 *in, uint32_t count)
24015 {
24016     VkDebugUtilsLabelEXT *out;
24017     unsigned int i;
24018
24019     if (!in || !count) return NULL;
24020
24021     out = conversion_context_alloc(ctx, count * sizeof(*out));
24022     for (i = 0; i < count; i++)
24023     {
24024         convert_VkDebugUtilsLabelEXT_win32_to_host(&in[i], &out[i]);
24025     }
24026
24027     return out;
24028 }
24029 #endif /* USE_STRUCT_CONVERSION */
24030
24031 #if !defined(USE_STRUCT_CONVERSION)
24032 static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT *in, uint32_t count)
24033 {
24034     VkDebugUtilsObjectNameInfoEXT *out;
24035     unsigned int i;
24036
24037     if (!in || !count) return NULL;
24038
24039     out = conversion_context_alloc(ctx, count * sizeof(*out));
24040     for (i = 0; i < count; i++)
24041     {
24042         convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(&in[i], &out[i]);
24043     }
24044
24045     return out;
24046 }
24047 #endif /* USE_STRUCT_CONVERSION */
24048
24049 #if defined(USE_STRUCT_CONVERSION)
24050 static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT32 *in, uint32_t count)
24051 {
24052     VkDebugUtilsObjectNameInfoEXT *out;
24053     unsigned int i;
24054
24055     if (!in || !count) return NULL;
24056
24057     out = conversion_context_alloc(ctx, count * sizeof(*out));
24058     for (i = 0; i < count; i++)
24059     {
24060         convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(&in[i], &out[i]);
24061     }
24062
24063     return out;
24064 }
24065 #endif /* USE_STRUCT_CONVERSION */
24066
24067 #if !defined(USE_STRUCT_CONVERSION)
24068 static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT *in, VkDebugUtilsMessengerCallbackDataEXT *out)
24069 {
24070     if (!in) return;
24071
24072     out->sType = in->sType;
24073     out->pNext = in->pNext;
24074     out->flags = in->flags;
24075     out->pMessageIdName = in->pMessageIdName;
24076     out->messageIdNumber = in->messageIdNumber;
24077     out->pMessage = in->pMessage;
24078     out->queueLabelCount = in->queueLabelCount;
24079     out->pQueueLabels = in->pQueueLabels;
24080     out->cmdBufLabelCount = in->cmdBufLabelCount;
24081     out->pCmdBufLabels = in->pCmdBufLabels;
24082     out->objectCount = in->objectCount;
24083     out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(ctx, in->pObjects, in->objectCount);
24084 }
24085 #endif /* USE_STRUCT_CONVERSION */
24086
24087 #if defined(USE_STRUCT_CONVERSION)
24088 static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT32 *in, VkDebugUtilsMessengerCallbackDataEXT *out)
24089 {
24090     const VkBaseInStructure *in_header;
24091     VkBaseOutStructure *out_header = (void *)out;
24092
24093     if (!in) return;
24094
24095     out->sType = in->sType;
24096     out->pNext = NULL;
24097     out->flags = in->flags;
24098     out->pMessageIdName = in->pMessageIdName;
24099     out->messageIdNumber = in->messageIdNumber;
24100     out->pMessage = in->pMessage;
24101     out->queueLabelCount = in->queueLabelCount;
24102     out->pQueueLabels = convert_VkDebugUtilsLabelEXT_array_win32_to_host(ctx, in->pQueueLabels, in->queueLabelCount);
24103     out->cmdBufLabelCount = in->cmdBufLabelCount;
24104     out->pCmdBufLabels = convert_VkDebugUtilsLabelEXT_array_win32_to_host(ctx, in->pCmdBufLabels, in->cmdBufLabelCount);
24105     out->objectCount = in->objectCount;
24106     out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win32_to_host(ctx, in->pObjects, in->objectCount);
24107
24108     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
24109     {
24110         switch (in_header->sType)
24111         {
24112         case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT:
24113         {
24114             VkDeviceAddressBindingCallbackDataEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24115             const VkDeviceAddressBindingCallbackDataEXT32 *in_ext = (const VkDeviceAddressBindingCallbackDataEXT32 *)in_header;
24116             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT;
24117             out_ext->pNext = NULL;
24118             out_ext->flags = in_ext->flags;
24119             out_ext->baseAddress = in_ext->baseAddress;
24120             out_ext->size = in_ext->size;
24121             out_ext->bindingType = in_ext->bindingType;
24122             out_header->pNext = (void *)out_ext;
24123             out_header = (void *)out_ext;
24124             break;
24125         }
24126         default:
24127             FIXME("Unhandled sType %u.", in_header->sType);
24128             break;
24129         }
24130     }
24131 }
24132 #endif /* USE_STRUCT_CONVERSION */
24133
24134 #if defined(USE_STRUCT_CONVERSION)
24135 static inline void convert_VkCopyDescriptorSet_win32_to_host(const VkCopyDescriptorSet32 *in, VkCopyDescriptorSet *out)
24136 {
24137     if (!in) return;
24138
24139     out->sType = in->sType;
24140     out->pNext = in->pNext;
24141     out->srcSet = in->srcSet;
24142     out->srcBinding = in->srcBinding;
24143     out->srcArrayElement = in->srcArrayElement;
24144     out->dstSet = in->dstSet;
24145     out->dstBinding = in->dstBinding;
24146     out->dstArrayElement = in->dstArrayElement;
24147     out->descriptorCount = in->descriptorCount;
24148 }
24149 #endif /* USE_STRUCT_CONVERSION */
24150
24151 #if defined(USE_STRUCT_CONVERSION)
24152 static inline const VkCopyDescriptorSet *convert_VkCopyDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkCopyDescriptorSet32 *in, uint32_t count)
24153 {
24154     VkCopyDescriptorSet *out;
24155     unsigned int i;
24156
24157     if (!in || !count) return NULL;
24158
24159     out = conversion_context_alloc(ctx, count * sizeof(*out));
24160     for (i = 0; i < count; i++)
24161     {
24162         convert_VkCopyDescriptorSet_win32_to_host(&in[i], &out[i]);
24163     }
24164
24165     return out;
24166 }
24167 #endif /* USE_STRUCT_CONVERSION */
24168
24169 #if defined(USE_STRUCT_CONVERSION)
24170 static inline void convert_VkSemaphoreWaitInfo_win32_to_host(const VkSemaphoreWaitInfo32 *in, VkSemaphoreWaitInfo *out)
24171 {
24172     if (!in) return;
24173
24174     out->sType = in->sType;
24175     out->pNext = in->pNext;
24176     out->flags = in->flags;
24177     out->semaphoreCount = in->semaphoreCount;
24178     out->pSemaphores = in->pSemaphores;
24179     out->pValues = in->pValues;
24180 }
24181 #endif /* USE_STRUCT_CONVERSION */
24182
24183 #if !defined(USE_STRUCT_CONVERSION)
24184
24185 static NTSTATUS thunk64_vkAcquireNextImage2KHR(void *args)
24186 {
24187     struct vkAcquireNextImage2KHR_params *params = args;
24188
24189     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pImageIndex);
24190
24191     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImage2KHR(wine_device_from_handle(params->device)->device, params->pAcquireInfo, params->pImageIndex);
24192     return STATUS_SUCCESS;
24193 }
24194
24195 #else /* USE_STRUCT_CONVERSION */
24196
24197 static NTSTATUS thunk32_vkAcquireNextImage2KHR(void *args)
24198 {
24199     struct
24200     {
24201         VkDevice device;
24202         const VkAcquireNextImageInfoKHR32 *pAcquireInfo;
24203         uint32_t *pImageIndex;
24204         VkResult result;
24205     } *params = args;
24206     VkAcquireNextImageInfoKHR pAcquireInfo_host;
24207
24208     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pImageIndex);
24209
24210     convert_VkAcquireNextImageInfoKHR_win32_to_host(params->pAcquireInfo, &pAcquireInfo_host);
24211     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImage2KHR(wine_device_from_handle(params->device)->device, &pAcquireInfo_host, params->pImageIndex);
24212     return STATUS_SUCCESS;
24213 }
24214
24215 #endif /* USE_STRUCT_CONVERSION */
24216
24217 #if !defined(USE_STRUCT_CONVERSION)
24218
24219 static NTSTATUS thunk64_vkAcquireNextImageKHR(void *args)
24220 {
24221     struct vkAcquireNextImageKHR_params *params = args;
24222
24223     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), wine_dbgstr_longlong(params->timeout), wine_dbgstr_longlong(params->semaphore), wine_dbgstr_longlong(params->fence), params->pImageIndex);
24224
24225     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImageKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->timeout, params->semaphore, params->fence, params->pImageIndex);
24226     return STATUS_SUCCESS;
24227 }
24228
24229 #else /* USE_STRUCT_CONVERSION */
24230
24231 static NTSTATUS thunk32_vkAcquireNextImageKHR(void *args)
24232 {
24233     struct
24234     {
24235         VkDevice device;
24236         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
24237         uint64_t DECLSPEC_ALIGN(8) timeout;
24238         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
24239         VkFence DECLSPEC_ALIGN(8) fence;
24240         uint32_t *pImageIndex;
24241         VkResult result;
24242     } *params = args;
24243
24244     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), wine_dbgstr_longlong(params->timeout), wine_dbgstr_longlong(params->semaphore), wine_dbgstr_longlong(params->fence), params->pImageIndex);
24245
24246     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImageKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->timeout, params->semaphore, params->fence, params->pImageIndex);
24247     return STATUS_SUCCESS;
24248 }
24249
24250 #endif /* USE_STRUCT_CONVERSION */
24251
24252 #if !defined(USE_STRUCT_CONVERSION)
24253
24254 static NTSTATUS thunk64_vkAcquirePerformanceConfigurationINTEL(void *args)
24255 {
24256     struct vkAcquirePerformanceConfigurationINTEL_params *params = args;
24257
24258     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pConfiguration);
24259
24260     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquirePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->pAcquireInfo, params->pConfiguration);
24261     return STATUS_SUCCESS;
24262 }
24263
24264 #else /* USE_STRUCT_CONVERSION */
24265
24266 static NTSTATUS thunk32_vkAcquirePerformanceConfigurationINTEL(void *args)
24267 {
24268     struct
24269     {
24270         VkDevice device;
24271         const VkPerformanceConfigurationAcquireInfoINTEL32 *pAcquireInfo;
24272         VkPerformanceConfigurationINTEL *pConfiguration;
24273         VkResult result;
24274     } *params = args;
24275     VkPerformanceConfigurationAcquireInfoINTEL pAcquireInfo_host;
24276
24277     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pConfiguration);
24278
24279     convert_VkPerformanceConfigurationAcquireInfoINTEL_win32_to_host(params->pAcquireInfo, &pAcquireInfo_host);
24280     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquirePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, &pAcquireInfo_host, params->pConfiguration);
24281     return STATUS_SUCCESS;
24282 }
24283
24284 #endif /* USE_STRUCT_CONVERSION */
24285
24286 #if !defined(USE_STRUCT_CONVERSION)
24287
24288 static NTSTATUS thunk64_vkAcquireProfilingLockKHR(void *args)
24289 {
24290     struct vkAcquireProfilingLockKHR_params *params = args;
24291
24292     TRACE("%p, %p\n", params->device, params->pInfo);
24293
24294     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireProfilingLockKHR(wine_device_from_handle(params->device)->device, params->pInfo);
24295     return STATUS_SUCCESS;
24296 }
24297
24298 #else /* USE_STRUCT_CONVERSION */
24299
24300 static NTSTATUS thunk32_vkAcquireProfilingLockKHR(void *args)
24301 {
24302     struct
24303     {
24304         VkDevice device;
24305         const VkAcquireProfilingLockInfoKHR32 *pInfo;
24306         VkResult result;
24307     } *params = args;
24308     VkAcquireProfilingLockInfoKHR pInfo_host;
24309
24310     TRACE("%p, %p\n", params->device, params->pInfo);
24311
24312     convert_VkAcquireProfilingLockInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
24313     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireProfilingLockKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
24314     return STATUS_SUCCESS;
24315 }
24316
24317 #endif /* USE_STRUCT_CONVERSION */
24318
24319 #if !defined(USE_STRUCT_CONVERSION)
24320
24321 static NTSTATUS thunk64_vkAllocateCommandBuffers(void *args)
24322 {
24323     struct vkAllocateCommandBuffers_params *params = args;
24324
24325     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pCommandBuffers);
24326
24327     params->result = wine_vkAllocateCommandBuffers(params->device, params->pAllocateInfo, params->pCommandBuffers);
24328     return STATUS_SUCCESS;
24329 }
24330
24331 #else /* USE_STRUCT_CONVERSION */
24332
24333 static NTSTATUS thunk32_vkAllocateCommandBuffers(void *args)
24334 {
24335     struct
24336     {
24337         VkDevice device;
24338         const VkCommandBufferAllocateInfo32 *pAllocateInfo;
24339         VkCommandBuffer *pCommandBuffers;
24340         VkResult result;
24341     } *params = args;
24342     VkCommandBufferAllocateInfo pAllocateInfo_host;
24343
24344     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pCommandBuffers);
24345
24346     convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host(params->pAllocateInfo, &pAllocateInfo_host);
24347     params->result = wine_vkAllocateCommandBuffers(params->device, &pAllocateInfo_host, params->pCommandBuffers);
24348     return STATUS_SUCCESS;
24349 }
24350
24351 #endif /* USE_STRUCT_CONVERSION */
24352
24353 #if !defined(USE_STRUCT_CONVERSION)
24354
24355 static NTSTATUS thunk64_vkAllocateDescriptorSets(void *args)
24356 {
24357     struct vkAllocateDescriptorSets_params *params = args;
24358
24359     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pDescriptorSets);
24360
24361     params->result = wine_device_from_handle(params->device)->funcs.p_vkAllocateDescriptorSets(wine_device_from_handle(params->device)->device, params->pAllocateInfo, params->pDescriptorSets);
24362     return STATUS_SUCCESS;
24363 }
24364
24365 #else /* USE_STRUCT_CONVERSION */
24366
24367 static NTSTATUS thunk32_vkAllocateDescriptorSets(void *args)
24368 {
24369     struct
24370     {
24371         VkDevice device;
24372         const VkDescriptorSetAllocateInfo32 *pAllocateInfo;
24373         VkDescriptorSet *pDescriptorSets;
24374         VkResult result;
24375     } *params = args;
24376     VkDescriptorSetAllocateInfo pAllocateInfo_host;
24377     struct conversion_context ctx;
24378
24379     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pDescriptorSets);
24380
24381     init_conversion_context(&ctx);
24382     convert_VkDescriptorSetAllocateInfo_win32_to_host(&ctx, params->pAllocateInfo, &pAllocateInfo_host);
24383     params->result = wine_device_from_handle(params->device)->funcs.p_vkAllocateDescriptorSets(wine_device_from_handle(params->device)->device, &pAllocateInfo_host, params->pDescriptorSets);
24384     free_conversion_context(&ctx);
24385     return STATUS_SUCCESS;
24386 }
24387
24388 #endif /* USE_STRUCT_CONVERSION */
24389
24390 #if !defined(USE_STRUCT_CONVERSION)
24391
24392 static NTSTATUS thunk64_vkAllocateMemory(void *args)
24393 {
24394     struct vkAllocateMemory_params *params = args;
24395
24396     TRACE("%p, %p, %p, %p\n", params->device, params->pAllocateInfo, params->pAllocator, params->pMemory);
24397
24398     params->result = wine_device_from_handle(params->device)->funcs.p_vkAllocateMemory(wine_device_from_handle(params->device)->device, params->pAllocateInfo, NULL, params->pMemory);
24399     return STATUS_SUCCESS;
24400 }
24401
24402 #else /* USE_STRUCT_CONVERSION */
24403
24404 static NTSTATUS thunk32_vkAllocateMemory(void *args)
24405 {
24406     struct
24407     {
24408         VkDevice device;
24409         const VkMemoryAllocateInfo32 *pAllocateInfo;
24410         const VkAllocationCallbacks *pAllocator;
24411         VkDeviceMemory *pMemory;
24412         VkResult result;
24413     } *params = args;
24414     VkMemoryAllocateInfo pAllocateInfo_host;
24415     struct conversion_context ctx;
24416
24417     TRACE("%p, %p, %p, %p\n", params->device, params->pAllocateInfo, params->pAllocator, params->pMemory);
24418
24419     init_conversion_context(&ctx);
24420     convert_VkMemoryAllocateInfo_win32_to_host(&ctx, params->pAllocateInfo, &pAllocateInfo_host);
24421     params->result = wine_device_from_handle(params->device)->funcs.p_vkAllocateMemory(wine_device_from_handle(params->device)->device, &pAllocateInfo_host, NULL, params->pMemory);
24422     free_conversion_context(&ctx);
24423     return STATUS_SUCCESS;
24424 }
24425
24426 #endif /* USE_STRUCT_CONVERSION */
24427
24428 #if !defined(USE_STRUCT_CONVERSION)
24429
24430 static NTSTATUS thunk64_vkBeginCommandBuffer(void *args)
24431 {
24432     struct vkBeginCommandBuffer_params *params = args;
24433
24434     TRACE("%p, %p\n", params->commandBuffer, params->pBeginInfo);
24435
24436     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkBeginCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBeginInfo);
24437     return STATUS_SUCCESS;
24438 }
24439
24440 #else /* USE_STRUCT_CONVERSION */
24441
24442 static NTSTATUS thunk32_vkBeginCommandBuffer(void *args)
24443 {
24444     struct
24445     {
24446         VkCommandBuffer commandBuffer;
24447         const VkCommandBufferBeginInfo32 *pBeginInfo;
24448         VkResult result;
24449     } *params = args;
24450     VkCommandBufferBeginInfo pBeginInfo_host;
24451     struct conversion_context ctx;
24452
24453     TRACE("%p, %p\n", params->commandBuffer, params->pBeginInfo);
24454
24455     init_conversion_context(&ctx);
24456     convert_VkCommandBufferBeginInfo_win32_to_host(&ctx, params->pBeginInfo, &pBeginInfo_host);
24457     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkBeginCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pBeginInfo_host);
24458     free_conversion_context(&ctx);
24459     return STATUS_SUCCESS;
24460 }
24461
24462 #endif /* USE_STRUCT_CONVERSION */
24463
24464 #if !defined(USE_STRUCT_CONVERSION)
24465
24466 static NTSTATUS thunk64_vkBindAccelerationStructureMemoryNV(void *args)
24467 {
24468     struct vkBindAccelerationStructureMemoryNV_params *params = args;
24469
24470     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
24471
24472     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindAccelerationStructureMemoryNV(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
24473     return STATUS_SUCCESS;
24474 }
24475
24476 #else /* USE_STRUCT_CONVERSION */
24477
24478 static NTSTATUS thunk32_vkBindAccelerationStructureMemoryNV(void *args)
24479 {
24480     struct
24481     {
24482         VkDevice device;
24483         uint32_t bindInfoCount;
24484         const VkBindAccelerationStructureMemoryInfoNV32 *pBindInfos;
24485         VkResult result;
24486     } *params = args;
24487     const VkBindAccelerationStructureMemoryInfoNV *pBindInfos_host;
24488     struct conversion_context ctx;
24489
24490     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
24491
24492     init_conversion_context(&ctx);
24493     pBindInfos_host = convert_VkBindAccelerationStructureMemoryInfoNV_array_win32_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
24494     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindAccelerationStructureMemoryNV(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
24495     free_conversion_context(&ctx);
24496     return STATUS_SUCCESS;
24497 }
24498
24499 #endif /* USE_STRUCT_CONVERSION */
24500
24501 #if !defined(USE_STRUCT_CONVERSION)
24502
24503 static NTSTATUS thunk64_vkBindBufferMemory(void *args)
24504 {
24505     struct vkBindBufferMemory_params *params = args;
24506
24507     TRACE("%p, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->memoryOffset));
24508
24509     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory(wine_device_from_handle(params->device)->device, params->buffer, params->memory, params->memoryOffset);
24510     return STATUS_SUCCESS;
24511 }
24512
24513 #else /* USE_STRUCT_CONVERSION */
24514
24515 static NTSTATUS thunk32_vkBindBufferMemory(void *args)
24516 {
24517     struct
24518     {
24519         VkDevice device;
24520         VkBuffer DECLSPEC_ALIGN(8) buffer;
24521         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
24522         VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
24523         VkResult result;
24524     } *params = args;
24525
24526     TRACE("%p, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->memoryOffset));
24527
24528     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory(wine_device_from_handle(params->device)->device, params->buffer, params->memory, params->memoryOffset);
24529     return STATUS_SUCCESS;
24530 }
24531
24532 #endif /* USE_STRUCT_CONVERSION */
24533
24534 #if !defined(USE_STRUCT_CONVERSION)
24535
24536 static NTSTATUS thunk64_vkBindBufferMemory2(void *args)
24537 {
24538     struct vkBindBufferMemory2_params *params = args;
24539
24540     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
24541
24542     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
24543     return STATUS_SUCCESS;
24544 }
24545
24546 #else /* USE_STRUCT_CONVERSION */
24547
24548 static NTSTATUS thunk32_vkBindBufferMemory2(void *args)
24549 {
24550     struct
24551     {
24552         VkDevice device;
24553         uint32_t bindInfoCount;
24554         const VkBindBufferMemoryInfo32 *pBindInfos;
24555         VkResult result;
24556     } *params = args;
24557     const VkBindBufferMemoryInfo *pBindInfos_host;
24558     struct conversion_context ctx;
24559
24560     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
24561
24562     init_conversion_context(&ctx);
24563     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win32_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
24564     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
24565     free_conversion_context(&ctx);
24566     return STATUS_SUCCESS;
24567 }
24568
24569 #endif /* USE_STRUCT_CONVERSION */
24570
24571 #if !defined(USE_STRUCT_CONVERSION)
24572
24573 static NTSTATUS thunk64_vkBindBufferMemory2KHR(void *args)
24574 {
24575     struct vkBindBufferMemory2KHR_params *params = args;
24576
24577     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
24578
24579     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
24580     return STATUS_SUCCESS;
24581 }
24582
24583 #else /* USE_STRUCT_CONVERSION */
24584
24585 static NTSTATUS thunk32_vkBindBufferMemory2KHR(void *args)
24586 {
24587     struct
24588     {
24589         VkDevice device;
24590         uint32_t bindInfoCount;
24591         const VkBindBufferMemoryInfo32 *pBindInfos;
24592         VkResult result;
24593     } *params = args;
24594     const VkBindBufferMemoryInfo *pBindInfos_host;
24595     struct conversion_context ctx;
24596
24597     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
24598
24599     init_conversion_context(&ctx);
24600     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win32_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
24601     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
24602     free_conversion_context(&ctx);
24603     return STATUS_SUCCESS;
24604 }
24605
24606 #endif /* USE_STRUCT_CONVERSION */
24607
24608 #if !defined(USE_STRUCT_CONVERSION)
24609
24610 static NTSTATUS thunk64_vkBindImageMemory(void *args)
24611 {
24612     struct vkBindImageMemory_params *params = args;
24613
24614     TRACE("%p, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->image), wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->memoryOffset));
24615
24616     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory(wine_device_from_handle(params->device)->device, params->image, params->memory, params->memoryOffset);
24617     return STATUS_SUCCESS;
24618 }
24619
24620 #else /* USE_STRUCT_CONVERSION */
24621
24622 static NTSTATUS thunk32_vkBindImageMemory(void *args)
24623 {
24624     struct
24625     {
24626         VkDevice device;
24627         VkImage DECLSPEC_ALIGN(8) image;
24628         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
24629         VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
24630         VkResult result;
24631     } *params = args;
24632
24633     TRACE("%p, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->image), wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->memoryOffset));
24634
24635     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory(wine_device_from_handle(params->device)->device, params->image, params->memory, params->memoryOffset);
24636     return STATUS_SUCCESS;
24637 }
24638
24639 #endif /* USE_STRUCT_CONVERSION */
24640
24641 #if !defined(USE_STRUCT_CONVERSION)
24642
24643 static NTSTATUS thunk64_vkBindImageMemory2(void *args)
24644 {
24645     struct vkBindImageMemory2_params *params = args;
24646
24647     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
24648
24649     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
24650     return STATUS_SUCCESS;
24651 }
24652
24653 #else /* USE_STRUCT_CONVERSION */
24654
24655 static NTSTATUS thunk32_vkBindImageMemory2(void *args)
24656 {
24657     struct
24658     {
24659         VkDevice device;
24660         uint32_t bindInfoCount;
24661         const VkBindImageMemoryInfo32 *pBindInfos;
24662         VkResult result;
24663     } *params = args;
24664     const VkBindImageMemoryInfo *pBindInfos_host;
24665     struct conversion_context ctx;
24666
24667     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
24668
24669     init_conversion_context(&ctx);
24670     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win32_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
24671     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
24672     free_conversion_context(&ctx);
24673     return STATUS_SUCCESS;
24674 }
24675
24676 #endif /* USE_STRUCT_CONVERSION */
24677
24678 #if !defined(USE_STRUCT_CONVERSION)
24679
24680 static NTSTATUS thunk64_vkBindImageMemory2KHR(void *args)
24681 {
24682     struct vkBindImageMemory2KHR_params *params = args;
24683
24684     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
24685
24686     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
24687     return STATUS_SUCCESS;
24688 }
24689
24690 #else /* USE_STRUCT_CONVERSION */
24691
24692 static NTSTATUS thunk32_vkBindImageMemory2KHR(void *args)
24693 {
24694     struct
24695     {
24696         VkDevice device;
24697         uint32_t bindInfoCount;
24698         const VkBindImageMemoryInfo32 *pBindInfos;
24699         VkResult result;
24700     } *params = args;
24701     const VkBindImageMemoryInfo *pBindInfos_host;
24702     struct conversion_context ctx;
24703
24704     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
24705
24706     init_conversion_context(&ctx);
24707     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win32_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
24708     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
24709     free_conversion_context(&ctx);
24710     return STATUS_SUCCESS;
24711 }
24712
24713 #endif /* USE_STRUCT_CONVERSION */
24714
24715 #if !defined(USE_STRUCT_CONVERSION)
24716
24717 static NTSTATUS thunk64_vkBindOpticalFlowSessionImageNV(void *args)
24718 {
24719     struct vkBindOpticalFlowSessionImageNV_params *params = args;
24720
24721     TRACE("%p, 0x%s, %#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->session), params->bindingPoint, wine_dbgstr_longlong(params->view), params->layout);
24722
24723     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindOpticalFlowSessionImageNV(wine_device_from_handle(params->device)->device, params->session, params->bindingPoint, params->view, params->layout);
24724     return STATUS_SUCCESS;
24725 }
24726
24727 #else /* USE_STRUCT_CONVERSION */
24728
24729 static NTSTATUS thunk32_vkBindOpticalFlowSessionImageNV(void *args)
24730 {
24731     struct
24732     {
24733         VkDevice device;
24734         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
24735         VkOpticalFlowSessionBindingPointNV bindingPoint;
24736         VkImageView DECLSPEC_ALIGN(8) view;
24737         VkImageLayout layout;
24738         VkResult result;
24739     } *params = args;
24740
24741     TRACE("%p, 0x%s, %#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->session), params->bindingPoint, wine_dbgstr_longlong(params->view), params->layout);
24742
24743     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindOpticalFlowSessionImageNV(wine_device_from_handle(params->device)->device, params->session, params->bindingPoint, params->view, params->layout);
24744     return STATUS_SUCCESS;
24745 }
24746
24747 #endif /* USE_STRUCT_CONVERSION */
24748
24749 #if !defined(USE_STRUCT_CONVERSION)
24750
24751 static NTSTATUS thunk64_vkBuildAccelerationStructuresKHR(void *args)
24752 {
24753     struct vkBuildAccelerationStructuresKHR_params *params = args;
24754
24755     TRACE("%p, 0x%s, %u, %p, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos, params->ppBuildRangeInfos);
24756
24757     params->result = wine_device_from_handle(params->device)->funcs.p_vkBuildAccelerationStructuresKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->infoCount, params->pInfos, params->ppBuildRangeInfos);
24758     return STATUS_SUCCESS;
24759 }
24760
24761 #else /* USE_STRUCT_CONVERSION */
24762
24763 static NTSTATUS thunk32_vkBuildAccelerationStructuresKHR(void *args)
24764 {
24765     struct
24766     {
24767         VkDevice device;
24768         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
24769         uint32_t infoCount;
24770         const VkAccelerationStructureBuildGeometryInfoKHR32 *pInfos;
24771         const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos;
24772         VkResult result;
24773     } *params = args;
24774     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
24775     struct conversion_context ctx;
24776
24777     TRACE("%p, 0x%s, %u, %p, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos, params->ppBuildRangeInfos);
24778
24779     init_conversion_context(&ctx);
24780     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, params->pInfos, params->infoCount);
24781     params->result = wine_device_from_handle(params->device)->funcs.p_vkBuildAccelerationStructuresKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->infoCount, pInfos_host, params->ppBuildRangeInfos);
24782     free_conversion_context(&ctx);
24783     return STATUS_SUCCESS;
24784 }
24785
24786 #endif /* USE_STRUCT_CONVERSION */
24787
24788 #if !defined(USE_STRUCT_CONVERSION)
24789
24790 static NTSTATUS thunk64_vkBuildMicromapsEXT(void *args)
24791 {
24792     struct vkBuildMicromapsEXT_params *params = args;
24793
24794     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos);
24795
24796     params->result = wine_device_from_handle(params->device)->funcs.p_vkBuildMicromapsEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->infoCount, params->pInfos);
24797     return STATUS_SUCCESS;
24798 }
24799
24800 #else /* USE_STRUCT_CONVERSION */
24801
24802 static NTSTATUS thunk32_vkBuildMicromapsEXT(void *args)
24803 {
24804     struct
24805     {
24806         VkDevice device;
24807         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
24808         uint32_t infoCount;
24809         const VkMicromapBuildInfoEXT32 *pInfos;
24810         VkResult result;
24811     } *params = args;
24812     const VkMicromapBuildInfoEXT *pInfos_host;
24813     struct conversion_context ctx;
24814
24815     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos);
24816
24817     init_conversion_context(&ctx);
24818     pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(&ctx, params->pInfos, params->infoCount);
24819     params->result = wine_device_from_handle(params->device)->funcs.p_vkBuildMicromapsEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->infoCount, pInfos_host);
24820     free_conversion_context(&ctx);
24821     return STATUS_SUCCESS;
24822 }
24823
24824 #endif /* USE_STRUCT_CONVERSION */
24825
24826 #if !defined(USE_STRUCT_CONVERSION)
24827
24828 static NTSTATUS thunk64_vkCmdBeginConditionalRenderingEXT(void *args)
24829 {
24830     struct vkCmdBeginConditionalRenderingEXT_params *params = args;
24831
24832     TRACE("%p, %p\n", params->commandBuffer, params->pConditionalRenderingBegin);
24833
24834     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pConditionalRenderingBegin);
24835     return STATUS_SUCCESS;
24836 }
24837
24838 #else /* USE_STRUCT_CONVERSION */
24839
24840 static NTSTATUS thunk32_vkCmdBeginConditionalRenderingEXT(void *args)
24841 {
24842     struct
24843     {
24844         VkCommandBuffer commandBuffer;
24845         const VkConditionalRenderingBeginInfoEXT32 *pConditionalRenderingBegin;
24846     } *params = args;
24847     VkConditionalRenderingBeginInfoEXT pConditionalRenderingBegin_host;
24848
24849     TRACE("%p, %p\n", params->commandBuffer, params->pConditionalRenderingBegin);
24850
24851     convert_VkConditionalRenderingBeginInfoEXT_win32_to_host(params->pConditionalRenderingBegin, &pConditionalRenderingBegin_host);
24852     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pConditionalRenderingBegin_host);
24853     return STATUS_SUCCESS;
24854 }
24855
24856 #endif /* USE_STRUCT_CONVERSION */
24857
24858 #if !defined(USE_STRUCT_CONVERSION)
24859
24860 static NTSTATUS thunk64_vkCmdBeginDebugUtilsLabelEXT(void *args)
24861 {
24862     struct vkCmdBeginDebugUtilsLabelEXT_params *params = args;
24863
24864     TRACE("%p, %p\n", params->commandBuffer, params->pLabelInfo);
24865
24866     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLabelInfo);
24867     return STATUS_SUCCESS;
24868 }
24869
24870 #else /* USE_STRUCT_CONVERSION */
24871
24872 static NTSTATUS thunk32_vkCmdBeginDebugUtilsLabelEXT(void *args)
24873 {
24874     struct
24875     {
24876         VkCommandBuffer commandBuffer;
24877         const VkDebugUtilsLabelEXT32 *pLabelInfo;
24878     } *params = args;
24879     VkDebugUtilsLabelEXT pLabelInfo_host;
24880
24881     TRACE("%p, %p\n", params->commandBuffer, params->pLabelInfo);
24882
24883     convert_VkDebugUtilsLabelEXT_win32_to_host(params->pLabelInfo, &pLabelInfo_host);
24884     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pLabelInfo_host);
24885     return STATUS_SUCCESS;
24886 }
24887
24888 #endif /* USE_STRUCT_CONVERSION */
24889
24890 #if !defined(USE_STRUCT_CONVERSION)
24891
24892 static NTSTATUS thunk64_vkCmdBeginQuery(void *args)
24893 {
24894     struct vkCmdBeginQuery_params *params = args;
24895
24896     TRACE("%p, 0x%s, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags);
24897
24898     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginQuery(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query, params->flags);
24899     return STATUS_SUCCESS;
24900 }
24901
24902 #else /* USE_STRUCT_CONVERSION */
24903
24904 static NTSTATUS thunk32_vkCmdBeginQuery(void *args)
24905 {
24906     struct
24907     {
24908         VkCommandBuffer commandBuffer;
24909         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
24910         uint32_t query;
24911         VkQueryControlFlags flags;
24912     } *params = args;
24913
24914     TRACE("%p, 0x%s, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags);
24915
24916     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginQuery(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query, params->flags);
24917     return STATUS_SUCCESS;
24918 }
24919
24920 #endif /* USE_STRUCT_CONVERSION */
24921
24922 #if !defined(USE_STRUCT_CONVERSION)
24923
24924 static NTSTATUS thunk64_vkCmdBeginQueryIndexedEXT(void *args)
24925 {
24926     struct vkCmdBeginQueryIndexedEXT_params *params = args;
24927
24928     TRACE("%p, 0x%s, %u, %#x, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags, params->index);
24929
24930     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginQueryIndexedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query, params->flags, params->index);
24931     return STATUS_SUCCESS;
24932 }
24933
24934 #else /* USE_STRUCT_CONVERSION */
24935
24936 static NTSTATUS thunk32_vkCmdBeginQueryIndexedEXT(void *args)
24937 {
24938     struct
24939     {
24940         VkCommandBuffer commandBuffer;
24941         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
24942         uint32_t query;
24943         VkQueryControlFlags flags;
24944         uint32_t index;
24945     } *params = args;
24946
24947     TRACE("%p, 0x%s, %u, %#x, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags, params->index);
24948
24949     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginQueryIndexedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query, params->flags, params->index);
24950     return STATUS_SUCCESS;
24951 }
24952
24953 #endif /* USE_STRUCT_CONVERSION */
24954
24955 #if !defined(USE_STRUCT_CONVERSION)
24956
24957 static NTSTATUS thunk64_vkCmdBeginRenderPass(void *args)
24958 {
24959     struct vkCmdBeginRenderPass_params *params = args;
24960
24961     TRACE("%p, %p, %#x\n", params->commandBuffer, params->pRenderPassBegin, params->contents);
24962
24963     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->contents);
24964     return STATUS_SUCCESS;
24965 }
24966
24967 #else /* USE_STRUCT_CONVERSION */
24968
24969 static NTSTATUS thunk32_vkCmdBeginRenderPass(void *args)
24970 {
24971     struct
24972     {
24973         VkCommandBuffer commandBuffer;
24974         const VkRenderPassBeginInfo32 *pRenderPassBegin;
24975         VkSubpassContents contents;
24976     } *params = args;
24977     VkRenderPassBeginInfo pRenderPassBegin_host;
24978     struct conversion_context ctx;
24979
24980     TRACE("%p, %p, %#x\n", params->commandBuffer, params->pRenderPassBegin, params->contents);
24981
24982     init_conversion_context(&ctx);
24983     convert_VkRenderPassBeginInfo_win32_to_host(&ctx, params->pRenderPassBegin, &pRenderPassBegin_host);
24984     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRenderPassBegin_host, params->contents);
24985     free_conversion_context(&ctx);
24986     return STATUS_SUCCESS;
24987 }
24988
24989 #endif /* USE_STRUCT_CONVERSION */
24990
24991 #if !defined(USE_STRUCT_CONVERSION)
24992
24993 static NTSTATUS thunk64_vkCmdBeginRenderPass2(void *args)
24994 {
24995     struct vkCmdBeginRenderPass2_params *params = args;
24996
24997     TRACE("%p, %p, %p\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
24998
24999     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
25000     return STATUS_SUCCESS;
25001 }
25002
25003 #else /* USE_STRUCT_CONVERSION */
25004
25005 static NTSTATUS thunk32_vkCmdBeginRenderPass2(void *args)
25006 {
25007     struct
25008     {
25009         VkCommandBuffer commandBuffer;
25010         const VkRenderPassBeginInfo32 *pRenderPassBegin;
25011         const VkSubpassBeginInfo32 *pSubpassBeginInfo;
25012     } *params = args;
25013     VkRenderPassBeginInfo pRenderPassBegin_host;
25014     VkSubpassBeginInfo pSubpassBeginInfo_host;
25015     struct conversion_context ctx;
25016
25017     TRACE("%p, %p, %p\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
25018
25019     init_conversion_context(&ctx);
25020     convert_VkRenderPassBeginInfo_win32_to_host(&ctx, params->pRenderPassBegin, &pRenderPassBegin_host);
25021     convert_VkSubpassBeginInfo_win32_to_host(params->pSubpassBeginInfo, &pSubpassBeginInfo_host);
25022     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRenderPassBegin_host, &pSubpassBeginInfo_host);
25023     free_conversion_context(&ctx);
25024     return STATUS_SUCCESS;
25025 }
25026
25027 #endif /* USE_STRUCT_CONVERSION */
25028
25029 #if !defined(USE_STRUCT_CONVERSION)
25030
25031 static NTSTATUS thunk64_vkCmdBeginRenderPass2KHR(void *args)
25032 {
25033     struct vkCmdBeginRenderPass2KHR_params *params = args;
25034
25035     TRACE("%p, %p, %p\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
25036
25037     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
25038     return STATUS_SUCCESS;
25039 }
25040
25041 #else /* USE_STRUCT_CONVERSION */
25042
25043 static NTSTATUS thunk32_vkCmdBeginRenderPass2KHR(void *args)
25044 {
25045     struct
25046     {
25047         VkCommandBuffer commandBuffer;
25048         const VkRenderPassBeginInfo32 *pRenderPassBegin;
25049         const VkSubpassBeginInfo32 *pSubpassBeginInfo;
25050     } *params = args;
25051     VkRenderPassBeginInfo pRenderPassBegin_host;
25052     VkSubpassBeginInfo pSubpassBeginInfo_host;
25053     struct conversion_context ctx;
25054
25055     TRACE("%p, %p, %p\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
25056
25057     init_conversion_context(&ctx);
25058     convert_VkRenderPassBeginInfo_win32_to_host(&ctx, params->pRenderPassBegin, &pRenderPassBegin_host);
25059     convert_VkSubpassBeginInfo_win32_to_host(params->pSubpassBeginInfo, &pSubpassBeginInfo_host);
25060     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRenderPassBegin_host, &pSubpassBeginInfo_host);
25061     free_conversion_context(&ctx);
25062     return STATUS_SUCCESS;
25063 }
25064
25065 #endif /* USE_STRUCT_CONVERSION */
25066
25067 #if !defined(USE_STRUCT_CONVERSION)
25068
25069 static NTSTATUS thunk64_vkCmdBeginRendering(void *args)
25070 {
25071     struct vkCmdBeginRendering_params *params = args;
25072
25073     TRACE("%p, %p\n", params->commandBuffer, params->pRenderingInfo);
25074
25075     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderingInfo);
25076     return STATUS_SUCCESS;
25077 }
25078
25079 #else /* USE_STRUCT_CONVERSION */
25080
25081 static NTSTATUS thunk32_vkCmdBeginRendering(void *args)
25082 {
25083     struct
25084     {
25085         VkCommandBuffer commandBuffer;
25086         const VkRenderingInfo32 *pRenderingInfo;
25087     } *params = args;
25088     VkRenderingInfo pRenderingInfo_host;
25089     struct conversion_context ctx;
25090
25091     TRACE("%p, %p\n", params->commandBuffer, params->pRenderingInfo);
25092
25093     init_conversion_context(&ctx);
25094     convert_VkRenderingInfo_win32_to_host(&ctx, params->pRenderingInfo, &pRenderingInfo_host);
25095     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRenderingInfo_host);
25096     free_conversion_context(&ctx);
25097     return STATUS_SUCCESS;
25098 }
25099
25100 #endif /* USE_STRUCT_CONVERSION */
25101
25102 #if !defined(USE_STRUCT_CONVERSION)
25103
25104 static NTSTATUS thunk64_vkCmdBeginRenderingKHR(void *args)
25105 {
25106     struct vkCmdBeginRenderingKHR_params *params = args;
25107
25108     TRACE("%p, %p\n", params->commandBuffer, params->pRenderingInfo);
25109
25110     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderingInfo);
25111     return STATUS_SUCCESS;
25112 }
25113
25114 #else /* USE_STRUCT_CONVERSION */
25115
25116 static NTSTATUS thunk32_vkCmdBeginRenderingKHR(void *args)
25117 {
25118     struct
25119     {
25120         VkCommandBuffer commandBuffer;
25121         const VkRenderingInfo32 *pRenderingInfo;
25122     } *params = args;
25123     VkRenderingInfo pRenderingInfo_host;
25124     struct conversion_context ctx;
25125
25126     TRACE("%p, %p\n", params->commandBuffer, params->pRenderingInfo);
25127
25128     init_conversion_context(&ctx);
25129     convert_VkRenderingInfo_win32_to_host(&ctx, params->pRenderingInfo, &pRenderingInfo_host);
25130     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRenderingInfo_host);
25131     free_conversion_context(&ctx);
25132     return STATUS_SUCCESS;
25133 }
25134
25135 #endif /* USE_STRUCT_CONVERSION */
25136
25137 #if !defined(USE_STRUCT_CONVERSION)
25138
25139 static NTSTATUS thunk64_vkCmdBeginTransformFeedbackEXT(void *args)
25140 {
25141     struct vkCmdBeginTransformFeedbackEXT_params *params = args;
25142
25143     TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
25144
25145     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginTransformFeedbackEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
25146     return STATUS_SUCCESS;
25147 }
25148
25149 #else /* USE_STRUCT_CONVERSION */
25150
25151 static NTSTATUS thunk32_vkCmdBeginTransformFeedbackEXT(void *args)
25152 {
25153     struct
25154     {
25155         VkCommandBuffer commandBuffer;
25156         uint32_t firstCounterBuffer;
25157         uint32_t counterBufferCount;
25158         const VkBuffer *pCounterBuffers;
25159         const VkDeviceSize *pCounterBufferOffsets;
25160     } *params = args;
25161
25162     TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
25163
25164     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginTransformFeedbackEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
25165     return STATUS_SUCCESS;
25166 }
25167
25168 #endif /* USE_STRUCT_CONVERSION */
25169
25170 #if !defined(USE_STRUCT_CONVERSION)
25171
25172 static NTSTATUS thunk64_vkCmdBindDescriptorSets(void *args)
25173 {
25174     struct vkCmdBindDescriptorSets_params *params = args;
25175
25176     TRACE("%p, %#x, 0x%s, %u, %u, %p, %u, %p\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->firstSet, params->descriptorSetCount, params->pDescriptorSets, params->dynamicOffsetCount, params->pDynamicOffsets);
25177
25178     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindDescriptorSets(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->layout, params->firstSet, params->descriptorSetCount, params->pDescriptorSets, params->dynamicOffsetCount, params->pDynamicOffsets);
25179     return STATUS_SUCCESS;
25180 }
25181
25182 #else /* USE_STRUCT_CONVERSION */
25183
25184 static NTSTATUS thunk32_vkCmdBindDescriptorSets(void *args)
25185 {
25186     struct
25187     {
25188         VkCommandBuffer commandBuffer;
25189         VkPipelineBindPoint pipelineBindPoint;
25190         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
25191         uint32_t firstSet;
25192         uint32_t descriptorSetCount;
25193         const VkDescriptorSet *pDescriptorSets;
25194         uint32_t dynamicOffsetCount;
25195         const uint32_t *pDynamicOffsets;
25196     } *params = args;
25197
25198     TRACE("%p, %#x, 0x%s, %u, %u, %p, %u, %p\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->firstSet, params->descriptorSetCount, params->pDescriptorSets, params->dynamicOffsetCount, params->pDynamicOffsets);
25199
25200     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindDescriptorSets(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->layout, params->firstSet, params->descriptorSetCount, params->pDescriptorSets, params->dynamicOffsetCount, params->pDynamicOffsets);
25201     return STATUS_SUCCESS;
25202 }
25203
25204 #endif /* USE_STRUCT_CONVERSION */
25205
25206 #if !defined(USE_STRUCT_CONVERSION)
25207
25208 static NTSTATUS thunk64_vkCmdBindIndexBuffer(void *args)
25209 {
25210     struct vkCmdBindIndexBuffer_params *params = args;
25211
25212     TRACE("%p, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->indexType);
25213
25214     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindIndexBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->indexType);
25215     return STATUS_SUCCESS;
25216 }
25217
25218 #else /* USE_STRUCT_CONVERSION */
25219
25220 static NTSTATUS thunk32_vkCmdBindIndexBuffer(void *args)
25221 {
25222     struct
25223     {
25224         VkCommandBuffer commandBuffer;
25225         VkBuffer DECLSPEC_ALIGN(8) buffer;
25226         VkDeviceSize DECLSPEC_ALIGN(8) offset;
25227         VkIndexType indexType;
25228     } *params = args;
25229
25230     TRACE("%p, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->indexType);
25231
25232     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindIndexBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->indexType);
25233     return STATUS_SUCCESS;
25234 }
25235
25236 #endif /* USE_STRUCT_CONVERSION */
25237
25238 #if !defined(USE_STRUCT_CONVERSION)
25239
25240 static NTSTATUS thunk64_vkCmdBindInvocationMaskHUAWEI(void *args)
25241 {
25242     struct vkCmdBindInvocationMaskHUAWEI_params *params = args;
25243
25244     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);
25245
25246     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindInvocationMaskHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
25247     return STATUS_SUCCESS;
25248 }
25249
25250 #else /* USE_STRUCT_CONVERSION */
25251
25252 static NTSTATUS thunk32_vkCmdBindInvocationMaskHUAWEI(void *args)
25253 {
25254     struct
25255     {
25256         VkCommandBuffer commandBuffer;
25257         VkImageView DECLSPEC_ALIGN(8) imageView;
25258         VkImageLayout imageLayout;
25259     } *params = args;
25260
25261     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);
25262
25263     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindInvocationMaskHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
25264     return STATUS_SUCCESS;
25265 }
25266
25267 #endif /* USE_STRUCT_CONVERSION */
25268
25269 #if !defined(USE_STRUCT_CONVERSION)
25270
25271 static NTSTATUS thunk64_vkCmdBindPipeline(void *args)
25272 {
25273     struct vkCmdBindPipeline_params *params = args;
25274
25275     TRACE("%p, %#x, 0x%s\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline));
25276
25277     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindPipeline(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->pipeline);
25278     return STATUS_SUCCESS;
25279 }
25280
25281 #else /* USE_STRUCT_CONVERSION */
25282
25283 static NTSTATUS thunk32_vkCmdBindPipeline(void *args)
25284 {
25285     struct
25286     {
25287         VkCommandBuffer commandBuffer;
25288         VkPipelineBindPoint pipelineBindPoint;
25289         VkPipeline DECLSPEC_ALIGN(8) pipeline;
25290     } *params = args;
25291
25292     TRACE("%p, %#x, 0x%s\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline));
25293
25294     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindPipeline(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->pipeline);
25295     return STATUS_SUCCESS;
25296 }
25297
25298 #endif /* USE_STRUCT_CONVERSION */
25299
25300 #if !defined(USE_STRUCT_CONVERSION)
25301
25302 static NTSTATUS thunk64_vkCmdBindPipelineShaderGroupNV(void *args)
25303 {
25304     struct vkCmdBindPipelineShaderGroupNV_params *params = args;
25305
25306     TRACE("%p, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline), params->groupIndex);
25307
25308     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindPipelineShaderGroupNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->pipeline, params->groupIndex);
25309     return STATUS_SUCCESS;
25310 }
25311
25312 #else /* USE_STRUCT_CONVERSION */
25313
25314 static NTSTATUS thunk32_vkCmdBindPipelineShaderGroupNV(void *args)
25315 {
25316     struct
25317     {
25318         VkCommandBuffer commandBuffer;
25319         VkPipelineBindPoint pipelineBindPoint;
25320         VkPipeline DECLSPEC_ALIGN(8) pipeline;
25321         uint32_t groupIndex;
25322     } *params = args;
25323
25324     TRACE("%p, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline), params->groupIndex);
25325
25326     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindPipelineShaderGroupNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->pipeline, params->groupIndex);
25327     return STATUS_SUCCESS;
25328 }
25329
25330 #endif /* USE_STRUCT_CONVERSION */
25331
25332 #if !defined(USE_STRUCT_CONVERSION)
25333
25334 static NTSTATUS thunk64_vkCmdBindShadingRateImageNV(void *args)
25335 {
25336     struct vkCmdBindShadingRateImageNV_params *params = args;
25337
25338     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);
25339
25340     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindShadingRateImageNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
25341     return STATUS_SUCCESS;
25342 }
25343
25344 #else /* USE_STRUCT_CONVERSION */
25345
25346 static NTSTATUS thunk32_vkCmdBindShadingRateImageNV(void *args)
25347 {
25348     struct
25349     {
25350         VkCommandBuffer commandBuffer;
25351         VkImageView DECLSPEC_ALIGN(8) imageView;
25352         VkImageLayout imageLayout;
25353     } *params = args;
25354
25355     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);
25356
25357     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindShadingRateImageNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
25358     return STATUS_SUCCESS;
25359 }
25360
25361 #endif /* USE_STRUCT_CONVERSION */
25362
25363 #if !defined(USE_STRUCT_CONVERSION)
25364
25365 static NTSTATUS thunk64_vkCmdBindTransformFeedbackBuffersEXT(void *args)
25366 {
25367     struct vkCmdBindTransformFeedbackBuffersEXT_params *params = args;
25368
25369     TRACE("%p, %u, %u, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes);
25370
25371     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindTransformFeedbackBuffersEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes);
25372     return STATUS_SUCCESS;
25373 }
25374
25375 #else /* USE_STRUCT_CONVERSION */
25376
25377 static NTSTATUS thunk32_vkCmdBindTransformFeedbackBuffersEXT(void *args)
25378 {
25379     struct
25380     {
25381         VkCommandBuffer commandBuffer;
25382         uint32_t firstBinding;
25383         uint32_t bindingCount;
25384         const VkBuffer *pBuffers;
25385         const VkDeviceSize *pOffsets;
25386         const VkDeviceSize *pSizes;
25387     } *params = args;
25388
25389     TRACE("%p, %u, %u, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes);
25390
25391     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindTransformFeedbackBuffersEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes);
25392     return STATUS_SUCCESS;
25393 }
25394
25395 #endif /* USE_STRUCT_CONVERSION */
25396
25397 #if !defined(USE_STRUCT_CONVERSION)
25398
25399 static NTSTATUS thunk64_vkCmdBindVertexBuffers(void *args)
25400 {
25401     struct vkCmdBindVertexBuffers_params *params = args;
25402
25403     TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets);
25404
25405     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindVertexBuffers(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets);
25406     return STATUS_SUCCESS;
25407 }
25408
25409 #else /* USE_STRUCT_CONVERSION */
25410
25411 static NTSTATUS thunk32_vkCmdBindVertexBuffers(void *args)
25412 {
25413     struct
25414     {
25415         VkCommandBuffer commandBuffer;
25416         uint32_t firstBinding;
25417         uint32_t bindingCount;
25418         const VkBuffer *pBuffers;
25419         const VkDeviceSize *pOffsets;
25420     } *params = args;
25421
25422     TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets);
25423
25424     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindVertexBuffers(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets);
25425     return STATUS_SUCCESS;
25426 }
25427
25428 #endif /* USE_STRUCT_CONVERSION */
25429
25430 #if !defined(USE_STRUCT_CONVERSION)
25431
25432 static NTSTATUS thunk64_vkCmdBindVertexBuffers2(void *args)
25433 {
25434     struct vkCmdBindVertexBuffers2_params *params = args;
25435
25436     TRACE("%p, %u, %u, %p, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
25437
25438     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindVertexBuffers2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
25439     return STATUS_SUCCESS;
25440 }
25441
25442 #else /* USE_STRUCT_CONVERSION */
25443
25444 static NTSTATUS thunk32_vkCmdBindVertexBuffers2(void *args)
25445 {
25446     struct
25447     {
25448         VkCommandBuffer commandBuffer;
25449         uint32_t firstBinding;
25450         uint32_t bindingCount;
25451         const VkBuffer *pBuffers;
25452         const VkDeviceSize *pOffsets;
25453         const VkDeviceSize *pSizes;
25454         const VkDeviceSize *pStrides;
25455     } *params = args;
25456
25457     TRACE("%p, %u, %u, %p, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
25458
25459     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindVertexBuffers2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
25460     return STATUS_SUCCESS;
25461 }
25462
25463 #endif /* USE_STRUCT_CONVERSION */
25464
25465 #if !defined(USE_STRUCT_CONVERSION)
25466
25467 static NTSTATUS thunk64_vkCmdBindVertexBuffers2EXT(void *args)
25468 {
25469     struct vkCmdBindVertexBuffers2EXT_params *params = args;
25470
25471     TRACE("%p, %u, %u, %p, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
25472
25473     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindVertexBuffers2EXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
25474     return STATUS_SUCCESS;
25475 }
25476
25477 #else /* USE_STRUCT_CONVERSION */
25478
25479 static NTSTATUS thunk32_vkCmdBindVertexBuffers2EXT(void *args)
25480 {
25481     struct
25482     {
25483         VkCommandBuffer commandBuffer;
25484         uint32_t firstBinding;
25485         uint32_t bindingCount;
25486         const VkBuffer *pBuffers;
25487         const VkDeviceSize *pOffsets;
25488         const VkDeviceSize *pSizes;
25489         const VkDeviceSize *pStrides;
25490     } *params = args;
25491
25492     TRACE("%p, %u, %u, %p, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
25493
25494     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindVertexBuffers2EXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
25495     return STATUS_SUCCESS;
25496 }
25497
25498 #endif /* USE_STRUCT_CONVERSION */
25499
25500 #if !defined(USE_STRUCT_CONVERSION)
25501
25502 static NTSTATUS thunk64_vkCmdBlitImage(void *args)
25503 {
25504     struct vkCmdBlitImage_params *params = args;
25505
25506     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions, params->filter);
25507
25508     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, params->pRegions, params->filter);
25509     return STATUS_SUCCESS;
25510 }
25511
25512 #else /* USE_STRUCT_CONVERSION */
25513
25514 static NTSTATUS thunk32_vkCmdBlitImage(void *args)
25515 {
25516     struct
25517     {
25518         VkCommandBuffer commandBuffer;
25519         VkImage DECLSPEC_ALIGN(8) srcImage;
25520         VkImageLayout srcImageLayout;
25521         VkImage DECLSPEC_ALIGN(8) dstImage;
25522         VkImageLayout dstImageLayout;
25523         uint32_t regionCount;
25524         const VkImageBlit *pRegions;
25525         VkFilter filter;
25526     } *params = args;
25527
25528     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions, params->filter);
25529
25530     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, params->pRegions, params->filter);
25531     return STATUS_SUCCESS;
25532 }
25533
25534 #endif /* USE_STRUCT_CONVERSION */
25535
25536 #if !defined(USE_STRUCT_CONVERSION)
25537
25538 static NTSTATUS thunk64_vkCmdBlitImage2(void *args)
25539 {
25540     struct vkCmdBlitImage2_params *params = args;
25541
25542     TRACE("%p, %p\n", params->commandBuffer, params->pBlitImageInfo);
25543
25544     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBlitImageInfo);
25545     return STATUS_SUCCESS;
25546 }
25547
25548 #else /* USE_STRUCT_CONVERSION */
25549
25550 static NTSTATUS thunk32_vkCmdBlitImage2(void *args)
25551 {
25552     struct
25553     {
25554         VkCommandBuffer commandBuffer;
25555         const VkBlitImageInfo232 *pBlitImageInfo;
25556     } *params = args;
25557     VkBlitImageInfo2 pBlitImageInfo_host;
25558     struct conversion_context ctx;
25559
25560     TRACE("%p, %p\n", params->commandBuffer, params->pBlitImageInfo);
25561
25562     init_conversion_context(&ctx);
25563     convert_VkBlitImageInfo2_win32_to_host(&ctx, params->pBlitImageInfo, &pBlitImageInfo_host);
25564     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pBlitImageInfo_host);
25565     free_conversion_context(&ctx);
25566     return STATUS_SUCCESS;
25567 }
25568
25569 #endif /* USE_STRUCT_CONVERSION */
25570
25571 #if !defined(USE_STRUCT_CONVERSION)
25572
25573 static NTSTATUS thunk64_vkCmdBlitImage2KHR(void *args)
25574 {
25575     struct vkCmdBlitImage2KHR_params *params = args;
25576
25577     TRACE("%p, %p\n", params->commandBuffer, params->pBlitImageInfo);
25578
25579     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBlitImageInfo);
25580     return STATUS_SUCCESS;
25581 }
25582
25583 #else /* USE_STRUCT_CONVERSION */
25584
25585 static NTSTATUS thunk32_vkCmdBlitImage2KHR(void *args)
25586 {
25587     struct
25588     {
25589         VkCommandBuffer commandBuffer;
25590         const VkBlitImageInfo232 *pBlitImageInfo;
25591     } *params = args;
25592     VkBlitImageInfo2 pBlitImageInfo_host;
25593     struct conversion_context ctx;
25594
25595     TRACE("%p, %p\n", params->commandBuffer, params->pBlitImageInfo);
25596
25597     init_conversion_context(&ctx);
25598     convert_VkBlitImageInfo2_win32_to_host(&ctx, params->pBlitImageInfo, &pBlitImageInfo_host);
25599     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pBlitImageInfo_host);
25600     free_conversion_context(&ctx);
25601     return STATUS_SUCCESS;
25602 }
25603
25604 #endif /* USE_STRUCT_CONVERSION */
25605
25606 #if !defined(USE_STRUCT_CONVERSION)
25607
25608 static NTSTATUS thunk64_vkCmdBuildAccelerationStructureNV(void *args)
25609 {
25610     struct vkCmdBuildAccelerationStructureNV_params *params = args;
25611
25612     TRACE("%p, %p, 0x%s, 0x%s, %u, 0x%s, 0x%s, 0x%s, 0x%s\n", params->commandBuffer, params->pInfo, wine_dbgstr_longlong(params->instanceData), wine_dbgstr_longlong(params->instanceOffset), params->update, wine_dbgstr_longlong(params->dst), wine_dbgstr_longlong(params->src), wine_dbgstr_longlong(params->scratch), wine_dbgstr_longlong(params->scratchOffset));
25613
25614     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildAccelerationStructureNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo, params->instanceData, params->instanceOffset, params->update, params->dst, params->src, params->scratch, params->scratchOffset);
25615     return STATUS_SUCCESS;
25616 }
25617
25618 #else /* USE_STRUCT_CONVERSION */
25619
25620 static NTSTATUS thunk32_vkCmdBuildAccelerationStructureNV(void *args)
25621 {
25622     struct
25623     {
25624         VkCommandBuffer commandBuffer;
25625         const VkAccelerationStructureInfoNV32 *pInfo;
25626         VkBuffer DECLSPEC_ALIGN(8) instanceData;
25627         VkDeviceSize DECLSPEC_ALIGN(8) instanceOffset;
25628         VkBool32 update;
25629         VkAccelerationStructureNV DECLSPEC_ALIGN(8) dst;
25630         VkAccelerationStructureNV DECLSPEC_ALIGN(8) src;
25631         VkBuffer DECLSPEC_ALIGN(8) scratch;
25632         VkDeviceSize DECLSPEC_ALIGN(8) scratchOffset;
25633     } *params = args;
25634     VkAccelerationStructureInfoNV pInfo_host;
25635     struct conversion_context ctx;
25636
25637     TRACE("%p, %p, 0x%s, 0x%s, %u, 0x%s, 0x%s, 0x%s, 0x%s\n", params->commandBuffer, params->pInfo, wine_dbgstr_longlong(params->instanceData), wine_dbgstr_longlong(params->instanceOffset), params->update, wine_dbgstr_longlong(params->dst), wine_dbgstr_longlong(params->src), wine_dbgstr_longlong(params->scratch), wine_dbgstr_longlong(params->scratchOffset));
25638
25639     init_conversion_context(&ctx);
25640     convert_VkAccelerationStructureInfoNV_win32_to_host(&ctx, params->pInfo, &pInfo_host);
25641     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildAccelerationStructureNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host, params->instanceData, params->instanceOffset, params->update, params->dst, params->src, params->scratch, params->scratchOffset);
25642     free_conversion_context(&ctx);
25643     return STATUS_SUCCESS;
25644 }
25645
25646 #endif /* USE_STRUCT_CONVERSION */
25647
25648 #if !defined(USE_STRUCT_CONVERSION)
25649
25650 static NTSTATUS thunk64_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
25651 {
25652     struct vkCmdBuildAccelerationStructuresIndirectKHR_params *params = args;
25653
25654     TRACE("%p, %u, %p, %p, %p, %p\n", params->commandBuffer, params->infoCount, params->pInfos, params->pIndirectDeviceAddresses, params->pIndirectStrides, params->ppMaxPrimitiveCounts);
25655
25656     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildAccelerationStructuresIndirectKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, params->pInfos, params->pIndirectDeviceAddresses, params->pIndirectStrides, params->ppMaxPrimitiveCounts);
25657     return STATUS_SUCCESS;
25658 }
25659
25660 #else /* USE_STRUCT_CONVERSION */
25661
25662 static NTSTATUS thunk32_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
25663 {
25664     struct
25665     {
25666         VkCommandBuffer commandBuffer;
25667         uint32_t infoCount;
25668         const VkAccelerationStructureBuildGeometryInfoKHR32 *pInfos;
25669         const VkDeviceAddress *pIndirectDeviceAddresses;
25670         const uint32_t *pIndirectStrides;
25671         const uint32_t * const*ppMaxPrimitiveCounts;
25672     } *params = args;
25673     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
25674     struct conversion_context ctx;
25675
25676     TRACE("%p, %u, %p, %p, %p, %p\n", params->commandBuffer, params->infoCount, params->pInfos, params->pIndirectDeviceAddresses, params->pIndirectStrides, params->ppMaxPrimitiveCounts);
25677
25678     init_conversion_context(&ctx);
25679     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, params->pInfos, params->infoCount);
25680     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildAccelerationStructuresIndirectKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, pInfos_host, params->pIndirectDeviceAddresses, params->pIndirectStrides, params->ppMaxPrimitiveCounts);
25681     free_conversion_context(&ctx);
25682     return STATUS_SUCCESS;
25683 }
25684
25685 #endif /* USE_STRUCT_CONVERSION */
25686
25687 #if !defined(USE_STRUCT_CONVERSION)
25688
25689 static NTSTATUS thunk64_vkCmdBuildAccelerationStructuresKHR(void *args)
25690 {
25691     struct vkCmdBuildAccelerationStructuresKHR_params *params = args;
25692
25693     TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->infoCount, params->pInfos, params->ppBuildRangeInfos);
25694
25695     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildAccelerationStructuresKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, params->pInfos, params->ppBuildRangeInfos);
25696     return STATUS_SUCCESS;
25697 }
25698
25699 #else /* USE_STRUCT_CONVERSION */
25700
25701 static NTSTATUS thunk32_vkCmdBuildAccelerationStructuresKHR(void *args)
25702 {
25703     struct
25704     {
25705         VkCommandBuffer commandBuffer;
25706         uint32_t infoCount;
25707         const VkAccelerationStructureBuildGeometryInfoKHR32 *pInfos;
25708         const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos;
25709     } *params = args;
25710     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
25711     struct conversion_context ctx;
25712
25713     TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->infoCount, params->pInfos, params->ppBuildRangeInfos);
25714
25715     init_conversion_context(&ctx);
25716     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, params->pInfos, params->infoCount);
25717     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildAccelerationStructuresKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, pInfos_host, params->ppBuildRangeInfos);
25718     free_conversion_context(&ctx);
25719     return STATUS_SUCCESS;
25720 }
25721
25722 #endif /* USE_STRUCT_CONVERSION */
25723
25724 #if !defined(USE_STRUCT_CONVERSION)
25725
25726 static NTSTATUS thunk64_vkCmdBuildMicromapsEXT(void *args)
25727 {
25728     struct vkCmdBuildMicromapsEXT_params *params = args;
25729
25730     TRACE("%p, %u, %p\n", params->commandBuffer, params->infoCount, params->pInfos);
25731
25732     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildMicromapsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, params->pInfos);
25733     return STATUS_SUCCESS;
25734 }
25735
25736 #else /* USE_STRUCT_CONVERSION */
25737
25738 static NTSTATUS thunk32_vkCmdBuildMicromapsEXT(void *args)
25739 {
25740     struct
25741     {
25742         VkCommandBuffer commandBuffer;
25743         uint32_t infoCount;
25744         const VkMicromapBuildInfoEXT32 *pInfos;
25745     } *params = args;
25746     const VkMicromapBuildInfoEXT *pInfos_host;
25747     struct conversion_context ctx;
25748
25749     TRACE("%p, %u, %p\n", params->commandBuffer, params->infoCount, params->pInfos);
25750
25751     init_conversion_context(&ctx);
25752     pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(&ctx, params->pInfos, params->infoCount);
25753     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildMicromapsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, pInfos_host);
25754     free_conversion_context(&ctx);
25755     return STATUS_SUCCESS;
25756 }
25757
25758 #endif /* USE_STRUCT_CONVERSION */
25759
25760 #if !defined(USE_STRUCT_CONVERSION)
25761
25762 static NTSTATUS thunk64_vkCmdClearAttachments(void *args)
25763 {
25764     struct vkCmdClearAttachments_params *params = args;
25765
25766     TRACE("%p, %u, %p, %u, %p\n", params->commandBuffer, params->attachmentCount, params->pAttachments, params->rectCount, params->pRects);
25767
25768     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdClearAttachments(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pAttachments, params->rectCount, params->pRects);
25769     return STATUS_SUCCESS;
25770 }
25771
25772 #else /* USE_STRUCT_CONVERSION */
25773
25774 static NTSTATUS thunk32_vkCmdClearAttachments(void *args)
25775 {
25776     struct
25777     {
25778         VkCommandBuffer commandBuffer;
25779         uint32_t attachmentCount;
25780         const VkClearAttachment *pAttachments;
25781         uint32_t rectCount;
25782         const VkClearRect *pRects;
25783     } *params = args;
25784
25785     TRACE("%p, %u, %p, %u, %p\n", params->commandBuffer, params->attachmentCount, params->pAttachments, params->rectCount, params->pRects);
25786
25787     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdClearAttachments(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pAttachments, params->rectCount, params->pRects);
25788     return STATUS_SUCCESS;
25789 }
25790
25791 #endif /* USE_STRUCT_CONVERSION */
25792
25793 #if !defined(USE_STRUCT_CONVERSION)
25794
25795 static NTSTATUS thunk64_vkCmdClearColorImage(void *args)
25796 {
25797     struct vkCmdClearColorImage_params *params = args;
25798
25799     TRACE("%p, 0x%s, %#x, %p, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pColor, params->rangeCount, params->pRanges);
25800
25801     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdClearColorImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->image, params->imageLayout, params->pColor, params->rangeCount, params->pRanges);
25802     return STATUS_SUCCESS;
25803 }
25804
25805 #else /* USE_STRUCT_CONVERSION */
25806
25807 static NTSTATUS thunk32_vkCmdClearColorImage(void *args)
25808 {
25809     struct
25810     {
25811         VkCommandBuffer commandBuffer;
25812         VkImage DECLSPEC_ALIGN(8) image;
25813         VkImageLayout imageLayout;
25814         const VkClearColorValue *pColor;
25815         uint32_t rangeCount;
25816         const VkImageSubresourceRange *pRanges;
25817     } *params = args;
25818
25819     TRACE("%p, 0x%s, %#x, %p, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pColor, params->rangeCount, params->pRanges);
25820
25821     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdClearColorImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->image, params->imageLayout, params->pColor, params->rangeCount, params->pRanges);
25822     return STATUS_SUCCESS;
25823 }
25824
25825 #endif /* USE_STRUCT_CONVERSION */
25826
25827 #if !defined(USE_STRUCT_CONVERSION)
25828
25829 static NTSTATUS thunk64_vkCmdClearDepthStencilImage(void *args)
25830 {
25831     struct vkCmdClearDepthStencilImage_params *params = args;
25832
25833     TRACE("%p, 0x%s, %#x, %p, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pDepthStencil, params->rangeCount, params->pRanges);
25834
25835     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdClearDepthStencilImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->image, params->imageLayout, params->pDepthStencil, params->rangeCount, params->pRanges);
25836     return STATUS_SUCCESS;
25837 }
25838
25839 #else /* USE_STRUCT_CONVERSION */
25840
25841 static NTSTATUS thunk32_vkCmdClearDepthStencilImage(void *args)
25842 {
25843     struct
25844     {
25845         VkCommandBuffer commandBuffer;
25846         VkImage DECLSPEC_ALIGN(8) image;
25847         VkImageLayout imageLayout;
25848         const VkClearDepthStencilValue *pDepthStencil;
25849         uint32_t rangeCount;
25850         const VkImageSubresourceRange *pRanges;
25851     } *params = args;
25852
25853     TRACE("%p, 0x%s, %#x, %p, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pDepthStencil, params->rangeCount, params->pRanges);
25854
25855     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdClearDepthStencilImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->image, params->imageLayout, params->pDepthStencil, params->rangeCount, params->pRanges);
25856     return STATUS_SUCCESS;
25857 }
25858
25859 #endif /* USE_STRUCT_CONVERSION */
25860
25861 #if !defined(USE_STRUCT_CONVERSION)
25862
25863 static NTSTATUS thunk64_vkCmdCopyAccelerationStructureKHR(void *args)
25864 {
25865     struct vkCmdCopyAccelerationStructureKHR_params *params = args;
25866
25867     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
25868
25869     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
25870     return STATUS_SUCCESS;
25871 }
25872
25873 #else /* USE_STRUCT_CONVERSION */
25874
25875 static NTSTATUS thunk32_vkCmdCopyAccelerationStructureKHR(void *args)
25876 {
25877     struct
25878     {
25879         VkCommandBuffer commandBuffer;
25880         const VkCopyAccelerationStructureInfoKHR32 *pInfo;
25881     } *params = args;
25882     VkCopyAccelerationStructureInfoKHR pInfo_host;
25883
25884     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
25885
25886     convert_VkCopyAccelerationStructureInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
25887     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
25888     return STATUS_SUCCESS;
25889 }
25890
25891 #endif /* USE_STRUCT_CONVERSION */
25892
25893 #if !defined(USE_STRUCT_CONVERSION)
25894
25895 static NTSTATUS thunk64_vkCmdCopyAccelerationStructureNV(void *args)
25896 {
25897     struct vkCmdCopyAccelerationStructureNV_params *params = args;
25898
25899     TRACE("%p, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->dst), wine_dbgstr_longlong(params->src), params->mode);
25900
25901     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->dst, params->src, params->mode);
25902     return STATUS_SUCCESS;
25903 }
25904
25905 #else /* USE_STRUCT_CONVERSION */
25906
25907 static NTSTATUS thunk32_vkCmdCopyAccelerationStructureNV(void *args)
25908 {
25909     struct
25910     {
25911         VkCommandBuffer commandBuffer;
25912         VkAccelerationStructureNV DECLSPEC_ALIGN(8) dst;
25913         VkAccelerationStructureNV DECLSPEC_ALIGN(8) src;
25914         VkCopyAccelerationStructureModeKHR mode;
25915     } *params = args;
25916
25917     TRACE("%p, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->dst), wine_dbgstr_longlong(params->src), params->mode);
25918
25919     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->dst, params->src, params->mode);
25920     return STATUS_SUCCESS;
25921 }
25922
25923 #endif /* USE_STRUCT_CONVERSION */
25924
25925 #if !defined(USE_STRUCT_CONVERSION)
25926
25927 static NTSTATUS thunk64_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)
25928 {
25929     struct vkCmdCopyAccelerationStructureToMemoryKHR_params *params = args;
25930
25931     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
25932
25933     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureToMemoryKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
25934     return STATUS_SUCCESS;
25935 }
25936
25937 #else /* USE_STRUCT_CONVERSION */
25938
25939 static NTSTATUS thunk32_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)
25940 {
25941     struct
25942     {
25943         VkCommandBuffer commandBuffer;
25944         const VkCopyAccelerationStructureToMemoryInfoKHR32 *pInfo;
25945     } *params = args;
25946     VkCopyAccelerationStructureToMemoryInfoKHR pInfo_host;
25947
25948     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
25949
25950     convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
25951     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureToMemoryKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
25952     return STATUS_SUCCESS;
25953 }
25954
25955 #endif /* USE_STRUCT_CONVERSION */
25956
25957 #if !defined(USE_STRUCT_CONVERSION)
25958
25959 static NTSTATUS thunk64_vkCmdCopyBuffer(void *args)
25960 {
25961     struct vkCmdCopyBuffer_params *params = args;
25962
25963     TRACE("%p, 0x%s, 0x%s, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcBuffer), wine_dbgstr_longlong(params->dstBuffer), params->regionCount, params->pRegions);
25964
25965     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcBuffer, params->dstBuffer, params->regionCount, params->pRegions);
25966     return STATUS_SUCCESS;
25967 }
25968
25969 #else /* USE_STRUCT_CONVERSION */
25970
25971 static NTSTATUS thunk32_vkCmdCopyBuffer(void *args)
25972 {
25973     struct
25974     {
25975         VkCommandBuffer commandBuffer;
25976         VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
25977         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
25978         uint32_t regionCount;
25979         const VkBufferCopy32 *pRegions;
25980     } *params = args;
25981     const VkBufferCopy *pRegions_host;
25982     struct conversion_context ctx;
25983
25984     TRACE("%p, 0x%s, 0x%s, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcBuffer), wine_dbgstr_longlong(params->dstBuffer), params->regionCount, params->pRegions);
25985
25986     init_conversion_context(&ctx);
25987     pRegions_host = convert_VkBufferCopy_array_win32_to_host(&ctx, params->pRegions, params->regionCount);
25988     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcBuffer, params->dstBuffer, params->regionCount, pRegions_host);
25989     free_conversion_context(&ctx);
25990     return STATUS_SUCCESS;
25991 }
25992
25993 #endif /* USE_STRUCT_CONVERSION */
25994
25995 #if !defined(USE_STRUCT_CONVERSION)
25996
25997 static NTSTATUS thunk64_vkCmdCopyBuffer2(void *args)
25998 {
25999     struct vkCmdCopyBuffer2_params *params = args;
26000
26001     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferInfo);
26002
26003     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferInfo);
26004     return STATUS_SUCCESS;
26005 }
26006
26007 #else /* USE_STRUCT_CONVERSION */
26008
26009 static NTSTATUS thunk32_vkCmdCopyBuffer2(void *args)
26010 {
26011     struct
26012     {
26013         VkCommandBuffer commandBuffer;
26014         const VkCopyBufferInfo232 *pCopyBufferInfo;
26015     } *params = args;
26016     VkCopyBufferInfo2 pCopyBufferInfo_host;
26017     struct conversion_context ctx;
26018
26019     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferInfo);
26020
26021     init_conversion_context(&ctx);
26022     convert_VkCopyBufferInfo2_win32_to_host(&ctx, params->pCopyBufferInfo, &pCopyBufferInfo_host);
26023     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyBufferInfo_host);
26024     free_conversion_context(&ctx);
26025     return STATUS_SUCCESS;
26026 }
26027
26028 #endif /* USE_STRUCT_CONVERSION */
26029
26030 #if !defined(USE_STRUCT_CONVERSION)
26031
26032 static NTSTATUS thunk64_vkCmdCopyBuffer2KHR(void *args)
26033 {
26034     struct vkCmdCopyBuffer2KHR_params *params = args;
26035
26036     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferInfo);
26037
26038     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferInfo);
26039     return STATUS_SUCCESS;
26040 }
26041
26042 #else /* USE_STRUCT_CONVERSION */
26043
26044 static NTSTATUS thunk32_vkCmdCopyBuffer2KHR(void *args)
26045 {
26046     struct
26047     {
26048         VkCommandBuffer commandBuffer;
26049         const VkCopyBufferInfo232 *pCopyBufferInfo;
26050     } *params = args;
26051     VkCopyBufferInfo2 pCopyBufferInfo_host;
26052     struct conversion_context ctx;
26053
26054     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferInfo);
26055
26056     init_conversion_context(&ctx);
26057     convert_VkCopyBufferInfo2_win32_to_host(&ctx, params->pCopyBufferInfo, &pCopyBufferInfo_host);
26058     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyBufferInfo_host);
26059     free_conversion_context(&ctx);
26060     return STATUS_SUCCESS;
26061 }
26062
26063 #endif /* USE_STRUCT_CONVERSION */
26064
26065 #if !defined(USE_STRUCT_CONVERSION)
26066
26067 static NTSTATUS thunk64_vkCmdCopyBufferToImage(void *args)
26068 {
26069     struct vkCmdCopyBufferToImage_params *params = args;
26070
26071     TRACE("%p, 0x%s, 0x%s, %#x, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcBuffer), wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
26072
26073     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcBuffer, params->dstImage, params->dstImageLayout, params->regionCount, params->pRegions);
26074     return STATUS_SUCCESS;
26075 }
26076
26077 #else /* USE_STRUCT_CONVERSION */
26078
26079 static NTSTATUS thunk32_vkCmdCopyBufferToImage(void *args)
26080 {
26081     struct
26082     {
26083         VkCommandBuffer commandBuffer;
26084         VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
26085         VkImage DECLSPEC_ALIGN(8) dstImage;
26086         VkImageLayout dstImageLayout;
26087         uint32_t regionCount;
26088         const VkBufferImageCopy32 *pRegions;
26089     } *params = args;
26090     const VkBufferImageCopy *pRegions_host;
26091     struct conversion_context ctx;
26092
26093     TRACE("%p, 0x%s, 0x%s, %#x, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcBuffer), wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
26094
26095     init_conversion_context(&ctx);
26096     pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(&ctx, params->pRegions, params->regionCount);
26097     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcBuffer, params->dstImage, params->dstImageLayout, params->regionCount, pRegions_host);
26098     free_conversion_context(&ctx);
26099     return STATUS_SUCCESS;
26100 }
26101
26102 #endif /* USE_STRUCT_CONVERSION */
26103
26104 #if !defined(USE_STRUCT_CONVERSION)
26105
26106 static NTSTATUS thunk64_vkCmdCopyBufferToImage2(void *args)
26107 {
26108     struct vkCmdCopyBufferToImage2_params *params = args;
26109
26110     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferToImageInfo);
26111
26112     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferToImageInfo);
26113     return STATUS_SUCCESS;
26114 }
26115
26116 #else /* USE_STRUCT_CONVERSION */
26117
26118 static NTSTATUS thunk32_vkCmdCopyBufferToImage2(void *args)
26119 {
26120     struct
26121     {
26122         VkCommandBuffer commandBuffer;
26123         const VkCopyBufferToImageInfo232 *pCopyBufferToImageInfo;
26124     } *params = args;
26125     VkCopyBufferToImageInfo2 pCopyBufferToImageInfo_host;
26126     struct conversion_context ctx;
26127
26128     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferToImageInfo);
26129
26130     init_conversion_context(&ctx);
26131     convert_VkCopyBufferToImageInfo2_win32_to_host(&ctx, params->pCopyBufferToImageInfo, &pCopyBufferToImageInfo_host);
26132     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyBufferToImageInfo_host);
26133     free_conversion_context(&ctx);
26134     return STATUS_SUCCESS;
26135 }
26136
26137 #endif /* USE_STRUCT_CONVERSION */
26138
26139 #if !defined(USE_STRUCT_CONVERSION)
26140
26141 static NTSTATUS thunk64_vkCmdCopyBufferToImage2KHR(void *args)
26142 {
26143     struct vkCmdCopyBufferToImage2KHR_params *params = args;
26144
26145     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferToImageInfo);
26146
26147     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferToImageInfo);
26148     return STATUS_SUCCESS;
26149 }
26150
26151 #else /* USE_STRUCT_CONVERSION */
26152
26153 static NTSTATUS thunk32_vkCmdCopyBufferToImage2KHR(void *args)
26154 {
26155     struct
26156     {
26157         VkCommandBuffer commandBuffer;
26158         const VkCopyBufferToImageInfo232 *pCopyBufferToImageInfo;
26159     } *params = args;
26160     VkCopyBufferToImageInfo2 pCopyBufferToImageInfo_host;
26161     struct conversion_context ctx;
26162
26163     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferToImageInfo);
26164
26165     init_conversion_context(&ctx);
26166     convert_VkCopyBufferToImageInfo2_win32_to_host(&ctx, params->pCopyBufferToImageInfo, &pCopyBufferToImageInfo_host);
26167     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyBufferToImageInfo_host);
26168     free_conversion_context(&ctx);
26169     return STATUS_SUCCESS;
26170 }
26171
26172 #endif /* USE_STRUCT_CONVERSION */
26173
26174 #if !defined(USE_STRUCT_CONVERSION)
26175
26176 static NTSTATUS thunk64_vkCmdCopyImage(void *args)
26177 {
26178     struct vkCmdCopyImage_params *params = args;
26179
26180     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
26181
26182     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, params->pRegions);
26183     return STATUS_SUCCESS;
26184 }
26185
26186 #else /* USE_STRUCT_CONVERSION */
26187
26188 static NTSTATUS thunk32_vkCmdCopyImage(void *args)
26189 {
26190     struct
26191     {
26192         VkCommandBuffer commandBuffer;
26193         VkImage DECLSPEC_ALIGN(8) srcImage;
26194         VkImageLayout srcImageLayout;
26195         VkImage DECLSPEC_ALIGN(8) dstImage;
26196         VkImageLayout dstImageLayout;
26197         uint32_t regionCount;
26198         const VkImageCopy *pRegions;
26199     } *params = args;
26200
26201     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
26202
26203     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, params->pRegions);
26204     return STATUS_SUCCESS;
26205 }
26206
26207 #endif /* USE_STRUCT_CONVERSION */
26208
26209 #if !defined(USE_STRUCT_CONVERSION)
26210
26211 static NTSTATUS thunk64_vkCmdCopyImage2(void *args)
26212 {
26213     struct vkCmdCopyImage2_params *params = args;
26214
26215     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageInfo);
26216
26217     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageInfo);
26218     return STATUS_SUCCESS;
26219 }
26220
26221 #else /* USE_STRUCT_CONVERSION */
26222
26223 static NTSTATUS thunk32_vkCmdCopyImage2(void *args)
26224 {
26225     struct
26226     {
26227         VkCommandBuffer commandBuffer;
26228         const VkCopyImageInfo232 *pCopyImageInfo;
26229     } *params = args;
26230     VkCopyImageInfo2 pCopyImageInfo_host;
26231     struct conversion_context ctx;
26232
26233     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageInfo);
26234
26235     init_conversion_context(&ctx);
26236     convert_VkCopyImageInfo2_win32_to_host(&ctx, params->pCopyImageInfo, &pCopyImageInfo_host);
26237     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyImageInfo_host);
26238     free_conversion_context(&ctx);
26239     return STATUS_SUCCESS;
26240 }
26241
26242 #endif /* USE_STRUCT_CONVERSION */
26243
26244 #if !defined(USE_STRUCT_CONVERSION)
26245
26246 static NTSTATUS thunk64_vkCmdCopyImage2KHR(void *args)
26247 {
26248     struct vkCmdCopyImage2KHR_params *params = args;
26249
26250     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageInfo);
26251
26252     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageInfo);
26253     return STATUS_SUCCESS;
26254 }
26255
26256 #else /* USE_STRUCT_CONVERSION */
26257
26258 static NTSTATUS thunk32_vkCmdCopyImage2KHR(void *args)
26259 {
26260     struct
26261     {
26262         VkCommandBuffer commandBuffer;
26263         const VkCopyImageInfo232 *pCopyImageInfo;
26264     } *params = args;
26265     VkCopyImageInfo2 pCopyImageInfo_host;
26266     struct conversion_context ctx;
26267
26268     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageInfo);
26269
26270     init_conversion_context(&ctx);
26271     convert_VkCopyImageInfo2_win32_to_host(&ctx, params->pCopyImageInfo, &pCopyImageInfo_host);
26272     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyImageInfo_host);
26273     free_conversion_context(&ctx);
26274     return STATUS_SUCCESS;
26275 }
26276
26277 #endif /* USE_STRUCT_CONVERSION */
26278
26279 #if !defined(USE_STRUCT_CONVERSION)
26280
26281 static NTSTATUS thunk64_vkCmdCopyImageToBuffer(void *args)
26282 {
26283     struct vkCmdCopyImageToBuffer_params *params = args;
26284
26285     TRACE("%p, 0x%s, %#x, 0x%s, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstBuffer), params->regionCount, params->pRegions);
26286
26287     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstBuffer, params->regionCount, params->pRegions);
26288     return STATUS_SUCCESS;
26289 }
26290
26291 #else /* USE_STRUCT_CONVERSION */
26292
26293 static NTSTATUS thunk32_vkCmdCopyImageToBuffer(void *args)
26294 {
26295     struct
26296     {
26297         VkCommandBuffer commandBuffer;
26298         VkImage DECLSPEC_ALIGN(8) srcImage;
26299         VkImageLayout srcImageLayout;
26300         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
26301         uint32_t regionCount;
26302         const VkBufferImageCopy32 *pRegions;
26303     } *params = args;
26304     const VkBufferImageCopy *pRegions_host;
26305     struct conversion_context ctx;
26306
26307     TRACE("%p, 0x%s, %#x, 0x%s, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstBuffer), params->regionCount, params->pRegions);
26308
26309     init_conversion_context(&ctx);
26310     pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(&ctx, params->pRegions, params->regionCount);
26311     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstBuffer, params->regionCount, pRegions_host);
26312     free_conversion_context(&ctx);
26313     return STATUS_SUCCESS;
26314 }
26315
26316 #endif /* USE_STRUCT_CONVERSION */
26317
26318 #if !defined(USE_STRUCT_CONVERSION)
26319
26320 static NTSTATUS thunk64_vkCmdCopyImageToBuffer2(void *args)
26321 {
26322     struct vkCmdCopyImageToBuffer2_params *params = args;
26323
26324     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageToBufferInfo);
26325
26326     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageToBufferInfo);
26327     return STATUS_SUCCESS;
26328 }
26329
26330 #else /* USE_STRUCT_CONVERSION */
26331
26332 static NTSTATUS thunk32_vkCmdCopyImageToBuffer2(void *args)
26333 {
26334     struct
26335     {
26336         VkCommandBuffer commandBuffer;
26337         const VkCopyImageToBufferInfo232 *pCopyImageToBufferInfo;
26338     } *params = args;
26339     VkCopyImageToBufferInfo2 pCopyImageToBufferInfo_host;
26340     struct conversion_context ctx;
26341
26342     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageToBufferInfo);
26343
26344     init_conversion_context(&ctx);
26345     convert_VkCopyImageToBufferInfo2_win32_to_host(&ctx, params->pCopyImageToBufferInfo, &pCopyImageToBufferInfo_host);
26346     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyImageToBufferInfo_host);
26347     free_conversion_context(&ctx);
26348     return STATUS_SUCCESS;
26349 }
26350
26351 #endif /* USE_STRUCT_CONVERSION */
26352
26353 #if !defined(USE_STRUCT_CONVERSION)
26354
26355 static NTSTATUS thunk64_vkCmdCopyImageToBuffer2KHR(void *args)
26356 {
26357     struct vkCmdCopyImageToBuffer2KHR_params *params = args;
26358
26359     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageToBufferInfo);
26360
26361     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageToBufferInfo);
26362     return STATUS_SUCCESS;
26363 }
26364
26365 #else /* USE_STRUCT_CONVERSION */
26366
26367 static NTSTATUS thunk32_vkCmdCopyImageToBuffer2KHR(void *args)
26368 {
26369     struct
26370     {
26371         VkCommandBuffer commandBuffer;
26372         const VkCopyImageToBufferInfo232 *pCopyImageToBufferInfo;
26373     } *params = args;
26374     VkCopyImageToBufferInfo2 pCopyImageToBufferInfo_host;
26375     struct conversion_context ctx;
26376
26377     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageToBufferInfo);
26378
26379     init_conversion_context(&ctx);
26380     convert_VkCopyImageToBufferInfo2_win32_to_host(&ctx, params->pCopyImageToBufferInfo, &pCopyImageToBufferInfo_host);
26381     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyImageToBufferInfo_host);
26382     free_conversion_context(&ctx);
26383     return STATUS_SUCCESS;
26384 }
26385
26386 #endif /* USE_STRUCT_CONVERSION */
26387
26388 #if !defined(USE_STRUCT_CONVERSION)
26389
26390 static NTSTATUS thunk64_vkCmdCopyMemoryIndirectNV(void *args)
26391 {
26392     struct vkCmdCopyMemoryIndirectNV_params *params = args;
26393
26394     TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->copyBufferAddress), params->copyCount, params->stride);
26395
26396     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryIndirectNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->copyBufferAddress, params->copyCount, params->stride);
26397     return STATUS_SUCCESS;
26398 }
26399
26400 #else /* USE_STRUCT_CONVERSION */
26401
26402 static NTSTATUS thunk32_vkCmdCopyMemoryIndirectNV(void *args)
26403 {
26404     struct
26405     {
26406         VkCommandBuffer commandBuffer;
26407         VkDeviceAddress DECLSPEC_ALIGN(8) copyBufferAddress;
26408         uint32_t copyCount;
26409         uint32_t stride;
26410     } *params = args;
26411
26412     TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->copyBufferAddress), params->copyCount, params->stride);
26413
26414     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryIndirectNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->copyBufferAddress, params->copyCount, params->stride);
26415     return STATUS_SUCCESS;
26416 }
26417
26418 #endif /* USE_STRUCT_CONVERSION */
26419
26420 #if !defined(USE_STRUCT_CONVERSION)
26421
26422 static NTSTATUS thunk64_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
26423 {
26424     struct vkCmdCopyMemoryToAccelerationStructureKHR_params *params = args;
26425
26426     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
26427
26428     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
26429     return STATUS_SUCCESS;
26430 }
26431
26432 #else /* USE_STRUCT_CONVERSION */
26433
26434 static NTSTATUS thunk32_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
26435 {
26436     struct
26437     {
26438         VkCommandBuffer commandBuffer;
26439         const VkCopyMemoryToAccelerationStructureInfoKHR32 *pInfo;
26440     } *params = args;
26441     VkCopyMemoryToAccelerationStructureInfoKHR pInfo_host;
26442
26443     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
26444
26445     convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
26446     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
26447     return STATUS_SUCCESS;
26448 }
26449
26450 #endif /* USE_STRUCT_CONVERSION */
26451
26452 #if !defined(USE_STRUCT_CONVERSION)
26453
26454 static NTSTATUS thunk64_vkCmdCopyMemoryToImageIndirectNV(void *args)
26455 {
26456     struct vkCmdCopyMemoryToImageIndirectNV_params *params = args;
26457
26458     TRACE("%p, 0x%s, %u, %u, 0x%s, %#x, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->copyBufferAddress), params->copyCount, params->stride, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->pImageSubresources);
26459
26460     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToImageIndirectNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->copyBufferAddress, params->copyCount, params->stride, params->dstImage, params->dstImageLayout, params->pImageSubresources);
26461     return STATUS_SUCCESS;
26462 }
26463
26464 #else /* USE_STRUCT_CONVERSION */
26465
26466 static NTSTATUS thunk32_vkCmdCopyMemoryToImageIndirectNV(void *args)
26467 {
26468     struct
26469     {
26470         VkCommandBuffer commandBuffer;
26471         VkDeviceAddress DECLSPEC_ALIGN(8) copyBufferAddress;
26472         uint32_t copyCount;
26473         uint32_t stride;
26474         VkImage DECLSPEC_ALIGN(8) dstImage;
26475         VkImageLayout dstImageLayout;
26476         const VkImageSubresourceLayers *pImageSubresources;
26477     } *params = args;
26478
26479     TRACE("%p, 0x%s, %u, %u, 0x%s, %#x, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->copyBufferAddress), params->copyCount, params->stride, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->pImageSubresources);
26480
26481     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToImageIndirectNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->copyBufferAddress, params->copyCount, params->stride, params->dstImage, params->dstImageLayout, params->pImageSubresources);
26482     return STATUS_SUCCESS;
26483 }
26484
26485 #endif /* USE_STRUCT_CONVERSION */
26486
26487 #if !defined(USE_STRUCT_CONVERSION)
26488
26489 static NTSTATUS thunk64_vkCmdCopyMemoryToMicromapEXT(void *args)
26490 {
26491     struct vkCmdCopyMemoryToMicromapEXT_params *params = args;
26492
26493     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
26494
26495     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
26496     return STATUS_SUCCESS;
26497 }
26498
26499 #else /* USE_STRUCT_CONVERSION */
26500
26501 static NTSTATUS thunk32_vkCmdCopyMemoryToMicromapEXT(void *args)
26502 {
26503     struct
26504     {
26505         VkCommandBuffer commandBuffer;
26506         const VkCopyMemoryToMicromapInfoEXT32 *pInfo;
26507     } *params = args;
26508     VkCopyMemoryToMicromapInfoEXT pInfo_host;
26509
26510     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
26511
26512     convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
26513     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
26514     return STATUS_SUCCESS;
26515 }
26516
26517 #endif /* USE_STRUCT_CONVERSION */
26518
26519 #if !defined(USE_STRUCT_CONVERSION)
26520
26521 static NTSTATUS thunk64_vkCmdCopyMicromapEXT(void *args)
26522 {
26523     struct vkCmdCopyMicromapEXT_params *params = args;
26524
26525     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
26526
26527     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
26528     return STATUS_SUCCESS;
26529 }
26530
26531 #else /* USE_STRUCT_CONVERSION */
26532
26533 static NTSTATUS thunk32_vkCmdCopyMicromapEXT(void *args)
26534 {
26535     struct
26536     {
26537         VkCommandBuffer commandBuffer;
26538         const VkCopyMicromapInfoEXT32 *pInfo;
26539     } *params = args;
26540     VkCopyMicromapInfoEXT pInfo_host;
26541
26542     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
26543
26544     convert_VkCopyMicromapInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
26545     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
26546     return STATUS_SUCCESS;
26547 }
26548
26549 #endif /* USE_STRUCT_CONVERSION */
26550
26551 #if !defined(USE_STRUCT_CONVERSION)
26552
26553 static NTSTATUS thunk64_vkCmdCopyMicromapToMemoryEXT(void *args)
26554 {
26555     struct vkCmdCopyMicromapToMemoryEXT_params *params = args;
26556
26557     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
26558
26559     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapToMemoryEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
26560     return STATUS_SUCCESS;
26561 }
26562
26563 #else /* USE_STRUCT_CONVERSION */
26564
26565 static NTSTATUS thunk32_vkCmdCopyMicromapToMemoryEXT(void *args)
26566 {
26567     struct
26568     {
26569         VkCommandBuffer commandBuffer;
26570         const VkCopyMicromapToMemoryInfoEXT32 *pInfo;
26571     } *params = args;
26572     VkCopyMicromapToMemoryInfoEXT pInfo_host;
26573
26574     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
26575
26576     convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
26577     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapToMemoryEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
26578     return STATUS_SUCCESS;
26579 }
26580
26581 #endif /* USE_STRUCT_CONVERSION */
26582
26583 #if !defined(USE_STRUCT_CONVERSION)
26584
26585 static NTSTATUS thunk64_vkCmdCopyQueryPoolResults(void *args)
26586 {
26587     struct vkCmdCopyQueryPoolResults_params *params = args;
26588
26589     TRACE("%p, 0x%s, %u, %u, 0x%s, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->stride), params->flags);
26590
26591     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyQueryPoolResults(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->firstQuery, params->queryCount, params->dstBuffer, params->dstOffset, params->stride, params->flags);
26592     return STATUS_SUCCESS;
26593 }
26594
26595 #else /* USE_STRUCT_CONVERSION */
26596
26597 static NTSTATUS thunk32_vkCmdCopyQueryPoolResults(void *args)
26598 {
26599     struct
26600     {
26601         VkCommandBuffer commandBuffer;
26602         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
26603         uint32_t firstQuery;
26604         uint32_t queryCount;
26605         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
26606         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
26607         VkDeviceSize DECLSPEC_ALIGN(8) stride;
26608         VkQueryResultFlags flags;
26609     } *params = args;
26610
26611     TRACE("%p, 0x%s, %u, %u, 0x%s, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->stride), params->flags);
26612
26613     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyQueryPoolResults(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->firstQuery, params->queryCount, params->dstBuffer, params->dstOffset, params->stride, params->flags);
26614     return STATUS_SUCCESS;
26615 }
26616
26617 #endif /* USE_STRUCT_CONVERSION */
26618
26619 #if !defined(USE_STRUCT_CONVERSION)
26620
26621 static NTSTATUS thunk64_vkCmdCuLaunchKernelNVX(void *args)
26622 {
26623     struct vkCmdCuLaunchKernelNVX_params *params = args;
26624
26625     TRACE("%p, %p\n", params->commandBuffer, params->pLaunchInfo);
26626
26627     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCuLaunchKernelNVX(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLaunchInfo);
26628     return STATUS_SUCCESS;
26629 }
26630
26631 #else /* USE_STRUCT_CONVERSION */
26632
26633 static NTSTATUS thunk32_vkCmdCuLaunchKernelNVX(void *args)
26634 {
26635     struct
26636     {
26637         VkCommandBuffer commandBuffer;
26638         const VkCuLaunchInfoNVX32 *pLaunchInfo;
26639     } *params = args;
26640     VkCuLaunchInfoNVX pLaunchInfo_host;
26641
26642     TRACE("%p, %p\n", params->commandBuffer, params->pLaunchInfo);
26643
26644     convert_VkCuLaunchInfoNVX_win32_to_host(params->pLaunchInfo, &pLaunchInfo_host);
26645     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCuLaunchKernelNVX(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pLaunchInfo_host);
26646     return STATUS_SUCCESS;
26647 }
26648
26649 #endif /* USE_STRUCT_CONVERSION */
26650
26651 #if !defined(USE_STRUCT_CONVERSION)
26652
26653 static NTSTATUS thunk64_vkCmdDebugMarkerBeginEXT(void *args)
26654 {
26655     struct vkCmdDebugMarkerBeginEXT_params *params = args;
26656
26657     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
26658
26659     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerBeginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
26660     return STATUS_SUCCESS;
26661 }
26662
26663 #else /* USE_STRUCT_CONVERSION */
26664
26665 static NTSTATUS thunk32_vkCmdDebugMarkerBeginEXT(void *args)
26666 {
26667     struct
26668     {
26669         VkCommandBuffer commandBuffer;
26670         const VkDebugMarkerMarkerInfoEXT32 *pMarkerInfo;
26671     } *params = args;
26672     VkDebugMarkerMarkerInfoEXT pMarkerInfo_host;
26673
26674     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
26675
26676     convert_VkDebugMarkerMarkerInfoEXT_win32_to_host(params->pMarkerInfo, &pMarkerInfo_host);
26677     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerBeginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pMarkerInfo_host);
26678     return STATUS_SUCCESS;
26679 }
26680
26681 #endif /* USE_STRUCT_CONVERSION */
26682
26683 #if !defined(USE_STRUCT_CONVERSION)
26684
26685 static NTSTATUS thunk64_vkCmdDebugMarkerEndEXT(void *args)
26686 {
26687     struct vkCmdDebugMarkerEndEXT_params *params = args;
26688
26689     TRACE("%p\n", params->commandBuffer);
26690
26691     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerEndEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
26692     return STATUS_SUCCESS;
26693 }
26694
26695 #else /* USE_STRUCT_CONVERSION */
26696
26697 static NTSTATUS thunk32_vkCmdDebugMarkerEndEXT(void *args)
26698 {
26699     struct
26700     {
26701         VkCommandBuffer commandBuffer;
26702     } *params = args;
26703
26704     TRACE("%p\n", params->commandBuffer);
26705
26706     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerEndEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
26707     return STATUS_SUCCESS;
26708 }
26709
26710 #endif /* USE_STRUCT_CONVERSION */
26711
26712 #if !defined(USE_STRUCT_CONVERSION)
26713
26714 static NTSTATUS thunk64_vkCmdDebugMarkerInsertEXT(void *args)
26715 {
26716     struct vkCmdDebugMarkerInsertEXT_params *params = args;
26717
26718     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
26719
26720     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerInsertEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
26721     return STATUS_SUCCESS;
26722 }
26723
26724 #else /* USE_STRUCT_CONVERSION */
26725
26726 static NTSTATUS thunk32_vkCmdDebugMarkerInsertEXT(void *args)
26727 {
26728     struct
26729     {
26730         VkCommandBuffer commandBuffer;
26731         const VkDebugMarkerMarkerInfoEXT32 *pMarkerInfo;
26732     } *params = args;
26733     VkDebugMarkerMarkerInfoEXT pMarkerInfo_host;
26734
26735     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
26736
26737     convert_VkDebugMarkerMarkerInfoEXT_win32_to_host(params->pMarkerInfo, &pMarkerInfo_host);
26738     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerInsertEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pMarkerInfo_host);
26739     return STATUS_SUCCESS;
26740 }
26741
26742 #endif /* USE_STRUCT_CONVERSION */
26743
26744 #if !defined(USE_STRUCT_CONVERSION)
26745
26746 static NTSTATUS thunk64_vkCmdDecompressMemoryIndirectCountNV(void *args)
26747 {
26748     struct vkCmdDecompressMemoryIndirectCountNV_params *params = args;
26749
26750     TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectCommandsAddress), wine_dbgstr_longlong(params->indirectCommandsCountAddress), params->stride);
26751
26752     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDecompressMemoryIndirectCountNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indirectCommandsAddress, params->indirectCommandsCountAddress, params->stride);
26753     return STATUS_SUCCESS;
26754 }
26755
26756 #else /* USE_STRUCT_CONVERSION */
26757
26758 static NTSTATUS thunk32_vkCmdDecompressMemoryIndirectCountNV(void *args)
26759 {
26760     struct
26761     {
26762         VkCommandBuffer commandBuffer;
26763         VkDeviceAddress DECLSPEC_ALIGN(8) indirectCommandsAddress;
26764         VkDeviceAddress DECLSPEC_ALIGN(8) indirectCommandsCountAddress;
26765         uint32_t stride;
26766     } *params = args;
26767
26768     TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectCommandsAddress), wine_dbgstr_longlong(params->indirectCommandsCountAddress), params->stride);
26769
26770     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDecompressMemoryIndirectCountNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indirectCommandsAddress, params->indirectCommandsCountAddress, params->stride);
26771     return STATUS_SUCCESS;
26772 }
26773
26774 #endif /* USE_STRUCT_CONVERSION */
26775
26776 #if !defined(USE_STRUCT_CONVERSION)
26777
26778 static NTSTATUS thunk64_vkCmdDecompressMemoryNV(void *args)
26779 {
26780     struct vkCmdDecompressMemoryNV_params *params = args;
26781
26782     TRACE("%p, %u, %p\n", params->commandBuffer, params->decompressRegionCount, params->pDecompressMemoryRegions);
26783
26784     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDecompressMemoryNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->decompressRegionCount, params->pDecompressMemoryRegions);
26785     return STATUS_SUCCESS;
26786 }
26787
26788 #else /* USE_STRUCT_CONVERSION */
26789
26790 static NTSTATUS thunk32_vkCmdDecompressMemoryNV(void *args)
26791 {
26792     struct
26793     {
26794         VkCommandBuffer commandBuffer;
26795         uint32_t decompressRegionCount;
26796         const VkDecompressMemoryRegionNV32 *pDecompressMemoryRegions;
26797     } *params = args;
26798     const VkDecompressMemoryRegionNV *pDecompressMemoryRegions_host;
26799     struct conversion_context ctx;
26800
26801     TRACE("%p, %u, %p\n", params->commandBuffer, params->decompressRegionCount, params->pDecompressMemoryRegions);
26802
26803     init_conversion_context(&ctx);
26804     pDecompressMemoryRegions_host = convert_VkDecompressMemoryRegionNV_array_win32_to_host(&ctx, params->pDecompressMemoryRegions, params->decompressRegionCount);
26805     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDecompressMemoryNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->decompressRegionCount, pDecompressMemoryRegions_host);
26806     free_conversion_context(&ctx);
26807     return STATUS_SUCCESS;
26808 }
26809
26810 #endif /* USE_STRUCT_CONVERSION */
26811
26812 #if !defined(USE_STRUCT_CONVERSION)
26813
26814 static NTSTATUS thunk64_vkCmdDispatch(void *args)
26815 {
26816     struct vkCmdDispatch_params *params = args;
26817
26818     TRACE("%p, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);
26819
26820     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatch(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->groupCountX, params->groupCountY, params->groupCountZ);
26821     return STATUS_SUCCESS;
26822 }
26823
26824 #else /* USE_STRUCT_CONVERSION */
26825
26826 static NTSTATUS thunk32_vkCmdDispatch(void *args)
26827 {
26828     struct
26829     {
26830         VkCommandBuffer commandBuffer;
26831         uint32_t groupCountX;
26832         uint32_t groupCountY;
26833         uint32_t groupCountZ;
26834     } *params = args;
26835
26836     TRACE("%p, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);
26837
26838     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatch(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->groupCountX, params->groupCountY, params->groupCountZ);
26839     return STATUS_SUCCESS;
26840 }
26841
26842 #endif /* USE_STRUCT_CONVERSION */
26843
26844 #if !defined(USE_STRUCT_CONVERSION)
26845
26846 static NTSTATUS thunk64_vkCmdDispatchBase(void *args)
26847 {
26848     struct vkCmdDispatchBase_params *params = args;
26849
26850     TRACE("%p, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
26851
26852     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchBase(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
26853     return STATUS_SUCCESS;
26854 }
26855
26856 #else /* USE_STRUCT_CONVERSION */
26857
26858 static NTSTATUS thunk32_vkCmdDispatchBase(void *args)
26859 {
26860     struct
26861     {
26862         VkCommandBuffer commandBuffer;
26863         uint32_t baseGroupX;
26864         uint32_t baseGroupY;
26865         uint32_t baseGroupZ;
26866         uint32_t groupCountX;
26867         uint32_t groupCountY;
26868         uint32_t groupCountZ;
26869     } *params = args;
26870
26871     TRACE("%p, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
26872
26873     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchBase(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
26874     return STATUS_SUCCESS;
26875 }
26876
26877 #endif /* USE_STRUCT_CONVERSION */
26878
26879 #if !defined(USE_STRUCT_CONVERSION)
26880
26881 static NTSTATUS thunk64_vkCmdDispatchBaseKHR(void *args)
26882 {
26883     struct vkCmdDispatchBaseKHR_params *params = args;
26884
26885     TRACE("%p, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
26886
26887     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchBaseKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
26888     return STATUS_SUCCESS;
26889 }
26890
26891 #else /* USE_STRUCT_CONVERSION */
26892
26893 static NTSTATUS thunk32_vkCmdDispatchBaseKHR(void *args)
26894 {
26895     struct
26896     {
26897         VkCommandBuffer commandBuffer;
26898         uint32_t baseGroupX;
26899         uint32_t baseGroupY;
26900         uint32_t baseGroupZ;
26901         uint32_t groupCountX;
26902         uint32_t groupCountY;
26903         uint32_t groupCountZ;
26904     } *params = args;
26905
26906     TRACE("%p, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
26907
26908     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchBaseKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
26909     return STATUS_SUCCESS;
26910 }
26911
26912 #endif /* USE_STRUCT_CONVERSION */
26913
26914 #if !defined(USE_STRUCT_CONVERSION)
26915
26916 static NTSTATUS thunk64_vkCmdDispatchIndirect(void *args)
26917 {
26918     struct vkCmdDispatchIndirect_params *params = args;
26919
26920     TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset));
26921
26922     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset);
26923     return STATUS_SUCCESS;
26924 }
26925
26926 #else /* USE_STRUCT_CONVERSION */
26927
26928 static NTSTATUS thunk32_vkCmdDispatchIndirect(void *args)
26929 {
26930     struct
26931     {
26932         VkCommandBuffer commandBuffer;
26933         VkBuffer DECLSPEC_ALIGN(8) buffer;
26934         VkDeviceSize DECLSPEC_ALIGN(8) offset;
26935     } *params = args;
26936
26937     TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset));
26938
26939     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset);
26940     return STATUS_SUCCESS;
26941 }
26942
26943 #endif /* USE_STRUCT_CONVERSION */
26944
26945 #if !defined(USE_STRUCT_CONVERSION)
26946
26947 static NTSTATUS thunk64_vkCmdDraw(void *args)
26948 {
26949     struct vkCmdDraw_params *params = args;
26950
26951     TRACE("%p, %u, %u, %u, %u\n", params->commandBuffer, params->vertexCount, params->instanceCount, params->firstVertex, params->firstInstance);
26952
26953     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDraw(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->vertexCount, params->instanceCount, params->firstVertex, params->firstInstance);
26954     return STATUS_SUCCESS;
26955 }
26956
26957 #else /* USE_STRUCT_CONVERSION */
26958
26959 static NTSTATUS thunk32_vkCmdDraw(void *args)
26960 {
26961     struct
26962     {
26963         VkCommandBuffer commandBuffer;
26964         uint32_t vertexCount;
26965         uint32_t instanceCount;
26966         uint32_t firstVertex;
26967         uint32_t firstInstance;
26968     } *params = args;
26969
26970     TRACE("%p, %u, %u, %u, %u\n", params->commandBuffer, params->vertexCount, params->instanceCount, params->firstVertex, params->firstInstance);
26971
26972     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDraw(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->vertexCount, params->instanceCount, params->firstVertex, params->firstInstance);
26973     return STATUS_SUCCESS;
26974 }
26975
26976 #endif /* USE_STRUCT_CONVERSION */
26977
26978 #if !defined(USE_STRUCT_CONVERSION)
26979
26980 static NTSTATUS thunk64_vkCmdDrawIndexed(void *args)
26981 {
26982     struct vkCmdDrawIndexed_params *params = args;
26983
26984     TRACE("%p, %u, %u, %u, %d, %u\n", params->commandBuffer, params->indexCount, params->instanceCount, params->firstIndex, params->vertexOffset, params->firstInstance);
26985
26986     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexed(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indexCount, params->instanceCount, params->firstIndex, params->vertexOffset, params->firstInstance);
26987     return STATUS_SUCCESS;
26988 }
26989
26990 #else /* USE_STRUCT_CONVERSION */
26991
26992 static NTSTATUS thunk32_vkCmdDrawIndexed(void *args)
26993 {
26994     struct
26995     {
26996         VkCommandBuffer commandBuffer;
26997         uint32_t indexCount;
26998         uint32_t instanceCount;
26999         uint32_t firstIndex;
27000         int32_t vertexOffset;
27001         uint32_t firstInstance;
27002     } *params = args;
27003
27004     TRACE("%p, %u, %u, %u, %d, %u\n", params->commandBuffer, params->indexCount, params->instanceCount, params->firstIndex, params->vertexOffset, params->firstInstance);
27005
27006     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexed(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indexCount, params->instanceCount, params->firstIndex, params->vertexOffset, params->firstInstance);
27007     return STATUS_SUCCESS;
27008 }
27009
27010 #endif /* USE_STRUCT_CONVERSION */
27011
27012 #if !defined(USE_STRUCT_CONVERSION)
27013
27014 static NTSTATUS thunk64_vkCmdDrawIndexedIndirect(void *args)
27015 {
27016     struct vkCmdDrawIndexedIndirect_params *params = args;
27017
27018     TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
27019
27020     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
27021     return STATUS_SUCCESS;
27022 }
27023
27024 #else /* USE_STRUCT_CONVERSION */
27025
27026 static NTSTATUS thunk32_vkCmdDrawIndexedIndirect(void *args)
27027 {
27028     struct
27029     {
27030         VkCommandBuffer commandBuffer;
27031         VkBuffer DECLSPEC_ALIGN(8) buffer;
27032         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27033         uint32_t drawCount;
27034         uint32_t stride;
27035     } *params = args;
27036
27037     TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
27038
27039     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
27040     return STATUS_SUCCESS;
27041 }
27042
27043 #endif /* USE_STRUCT_CONVERSION */
27044
27045 #if !defined(USE_STRUCT_CONVERSION)
27046
27047 static NTSTATUS thunk64_vkCmdDrawIndexedIndirectCount(void *args)
27048 {
27049     struct vkCmdDrawIndexedIndirectCount_params *params = args;
27050
27051     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27052
27053     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirectCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
27054     return STATUS_SUCCESS;
27055 }
27056
27057 #else /* USE_STRUCT_CONVERSION */
27058
27059 static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCount(void *args)
27060 {
27061     struct
27062     {
27063         VkCommandBuffer commandBuffer;
27064         VkBuffer DECLSPEC_ALIGN(8) buffer;
27065         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27066         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
27067         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
27068         uint32_t maxDrawCount;
27069         uint32_t stride;
27070     } *params = args;
27071
27072     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27073
27074     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirectCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
27075     return STATUS_SUCCESS;
27076 }
27077
27078 #endif /* USE_STRUCT_CONVERSION */
27079
27080 #if !defined(USE_STRUCT_CONVERSION)
27081
27082 static NTSTATUS thunk64_vkCmdDrawIndexedIndirectCountAMD(void *args)
27083 {
27084     struct vkCmdDrawIndexedIndirectCountAMD_params *params = args;
27085
27086     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27087
27088     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirectCountAMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
27089     return STATUS_SUCCESS;
27090 }
27091
27092 #else /* USE_STRUCT_CONVERSION */
27093
27094 static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCountAMD(void *args)
27095 {
27096     struct
27097     {
27098         VkCommandBuffer commandBuffer;
27099         VkBuffer DECLSPEC_ALIGN(8) buffer;
27100         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27101         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
27102         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
27103         uint32_t maxDrawCount;
27104         uint32_t stride;
27105     } *params = args;
27106
27107     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27108
27109     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirectCountAMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
27110     return STATUS_SUCCESS;
27111 }
27112
27113 #endif /* USE_STRUCT_CONVERSION */
27114
27115 #if !defined(USE_STRUCT_CONVERSION)
27116
27117 static NTSTATUS thunk64_vkCmdDrawIndexedIndirectCountKHR(void *args)
27118 {
27119     struct vkCmdDrawIndexedIndirectCountKHR_params *params = args;
27120
27121     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27122
27123     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirectCountKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
27124     return STATUS_SUCCESS;
27125 }
27126
27127 #else /* USE_STRUCT_CONVERSION */
27128
27129 static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCountKHR(void *args)
27130 {
27131     struct
27132     {
27133         VkCommandBuffer commandBuffer;
27134         VkBuffer DECLSPEC_ALIGN(8) buffer;
27135         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27136         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
27137         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
27138         uint32_t maxDrawCount;
27139         uint32_t stride;
27140     } *params = args;
27141
27142     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27143
27144     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirectCountKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
27145     return STATUS_SUCCESS;
27146 }
27147
27148 #endif /* USE_STRUCT_CONVERSION */
27149
27150 #if !defined(USE_STRUCT_CONVERSION)
27151
27152 static NTSTATUS thunk64_vkCmdDrawIndirect(void *args)
27153 {
27154     struct vkCmdDrawIndirect_params *params = args;
27155
27156     TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
27157
27158     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
27159     return STATUS_SUCCESS;
27160 }
27161
27162 #else /* USE_STRUCT_CONVERSION */
27163
27164 static NTSTATUS thunk32_vkCmdDrawIndirect(void *args)
27165 {
27166     struct
27167     {
27168         VkCommandBuffer commandBuffer;
27169         VkBuffer DECLSPEC_ALIGN(8) buffer;
27170         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27171         uint32_t drawCount;
27172         uint32_t stride;
27173     } *params = args;
27174
27175     TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
27176
27177     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
27178     return STATUS_SUCCESS;
27179 }
27180
27181 #endif /* USE_STRUCT_CONVERSION */
27182
27183 #if !defined(USE_STRUCT_CONVERSION)
27184
27185 static NTSTATUS thunk64_vkCmdDrawIndirectByteCountEXT(void *args)
27186 {
27187     struct vkCmdDrawIndirectByteCountEXT_params *params = args;
27188
27189     TRACE("%p, %u, %u, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, params->instanceCount, params->firstInstance, wine_dbgstr_longlong(params->counterBuffer), wine_dbgstr_longlong(params->counterBufferOffset), params->counterOffset, params->vertexStride);
27190
27191     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectByteCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->instanceCount, params->firstInstance, params->counterBuffer, params->counterBufferOffset, params->counterOffset, params->vertexStride);
27192     return STATUS_SUCCESS;
27193 }
27194
27195 #else /* USE_STRUCT_CONVERSION */
27196
27197 static NTSTATUS thunk32_vkCmdDrawIndirectByteCountEXT(void *args)
27198 {
27199     struct
27200     {
27201         VkCommandBuffer commandBuffer;
27202         uint32_t instanceCount;
27203         uint32_t firstInstance;
27204         VkBuffer DECLSPEC_ALIGN(8) counterBuffer;
27205         VkDeviceSize DECLSPEC_ALIGN(8) counterBufferOffset;
27206         uint32_t counterOffset;
27207         uint32_t vertexStride;
27208     } *params = args;
27209
27210     TRACE("%p, %u, %u, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, params->instanceCount, params->firstInstance, wine_dbgstr_longlong(params->counterBuffer), wine_dbgstr_longlong(params->counterBufferOffset), params->counterOffset, params->vertexStride);
27211
27212     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectByteCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->instanceCount, params->firstInstance, params->counterBuffer, params->counterBufferOffset, params->counterOffset, params->vertexStride);
27213     return STATUS_SUCCESS;
27214 }
27215
27216 #endif /* USE_STRUCT_CONVERSION */
27217
27218 #if !defined(USE_STRUCT_CONVERSION)
27219
27220 static NTSTATUS thunk64_vkCmdDrawIndirectCount(void *args)
27221 {
27222     struct vkCmdDrawIndirectCount_params *params = args;
27223
27224     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27225
27226     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
27227     return STATUS_SUCCESS;
27228 }
27229
27230 #else /* USE_STRUCT_CONVERSION */
27231
27232 static NTSTATUS thunk32_vkCmdDrawIndirectCount(void *args)
27233 {
27234     struct
27235     {
27236         VkCommandBuffer commandBuffer;
27237         VkBuffer DECLSPEC_ALIGN(8) buffer;
27238         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27239         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
27240         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
27241         uint32_t maxDrawCount;
27242         uint32_t stride;
27243     } *params = args;
27244
27245     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27246
27247     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
27248     return STATUS_SUCCESS;
27249 }
27250
27251 #endif /* USE_STRUCT_CONVERSION */
27252
27253 #if !defined(USE_STRUCT_CONVERSION)
27254
27255 static NTSTATUS thunk64_vkCmdDrawIndirectCountAMD(void *args)
27256 {
27257     struct vkCmdDrawIndirectCountAMD_params *params = args;
27258
27259     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27260
27261     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectCountAMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
27262     return STATUS_SUCCESS;
27263 }
27264
27265 #else /* USE_STRUCT_CONVERSION */
27266
27267 static NTSTATUS thunk32_vkCmdDrawIndirectCountAMD(void *args)
27268 {
27269     struct
27270     {
27271         VkCommandBuffer commandBuffer;
27272         VkBuffer DECLSPEC_ALIGN(8) buffer;
27273         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27274         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
27275         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
27276         uint32_t maxDrawCount;
27277         uint32_t stride;
27278     } *params = args;
27279
27280     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27281
27282     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectCountAMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
27283     return STATUS_SUCCESS;
27284 }
27285
27286 #endif /* USE_STRUCT_CONVERSION */
27287
27288 #if !defined(USE_STRUCT_CONVERSION)
27289
27290 static NTSTATUS thunk64_vkCmdDrawIndirectCountKHR(void *args)
27291 {
27292     struct vkCmdDrawIndirectCountKHR_params *params = args;
27293
27294     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27295
27296     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectCountKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
27297     return STATUS_SUCCESS;
27298 }
27299
27300 #else /* USE_STRUCT_CONVERSION */
27301
27302 static NTSTATUS thunk32_vkCmdDrawIndirectCountKHR(void *args)
27303 {
27304     struct
27305     {
27306         VkCommandBuffer commandBuffer;
27307         VkBuffer DECLSPEC_ALIGN(8) buffer;
27308         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27309         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
27310         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
27311         uint32_t maxDrawCount;
27312         uint32_t stride;
27313     } *params = args;
27314
27315     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27316
27317     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectCountKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
27318     return STATUS_SUCCESS;
27319 }
27320
27321 #endif /* USE_STRUCT_CONVERSION */
27322
27323 #if !defined(USE_STRUCT_CONVERSION)
27324
27325 static NTSTATUS thunk64_vkCmdDrawMeshTasksEXT(void *args)
27326 {
27327     struct vkCmdDrawMeshTasksEXT_params *params = args;
27328
27329     TRACE("%p, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);
27330
27331     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->groupCountX, params->groupCountY, params->groupCountZ);
27332     return STATUS_SUCCESS;
27333 }
27334
27335 #else /* USE_STRUCT_CONVERSION */
27336
27337 static NTSTATUS thunk32_vkCmdDrawMeshTasksEXT(void *args)
27338 {
27339     struct
27340     {
27341         VkCommandBuffer commandBuffer;
27342         uint32_t groupCountX;
27343         uint32_t groupCountY;
27344         uint32_t groupCountZ;
27345     } *params = args;
27346
27347     TRACE("%p, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);
27348
27349     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->groupCountX, params->groupCountY, params->groupCountZ);
27350     return STATUS_SUCCESS;
27351 }
27352
27353 #endif /* USE_STRUCT_CONVERSION */
27354
27355 #if !defined(USE_STRUCT_CONVERSION)
27356
27357 static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
27358 {
27359     struct vkCmdDrawMeshTasksIndirectCountEXT_params *params = args;
27360
27361     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27362
27363     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
27364     return STATUS_SUCCESS;
27365 }
27366
27367 #else /* USE_STRUCT_CONVERSION */
27368
27369 static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
27370 {
27371     struct
27372     {
27373         VkCommandBuffer commandBuffer;
27374         VkBuffer DECLSPEC_ALIGN(8) buffer;
27375         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27376         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
27377         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
27378         uint32_t maxDrawCount;
27379         uint32_t stride;
27380     } *params = args;
27381
27382     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27383
27384     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
27385     return STATUS_SUCCESS;
27386 }
27387
27388 #endif /* USE_STRUCT_CONVERSION */
27389
27390 #if !defined(USE_STRUCT_CONVERSION)
27391
27392 static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectCountNV(void *args)
27393 {
27394     struct vkCmdDrawMeshTasksIndirectCountNV_params *params = args;
27395
27396     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27397
27398     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectCountNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
27399     return STATUS_SUCCESS;
27400 }
27401
27402 #else /* USE_STRUCT_CONVERSION */
27403
27404 static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectCountNV(void *args)
27405 {
27406     struct
27407     {
27408         VkCommandBuffer commandBuffer;
27409         VkBuffer DECLSPEC_ALIGN(8) buffer;
27410         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27411         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
27412         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
27413         uint32_t maxDrawCount;
27414         uint32_t stride;
27415     } *params = args;
27416
27417     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27418
27419     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectCountNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
27420     return STATUS_SUCCESS;
27421 }
27422
27423 #endif /* USE_STRUCT_CONVERSION */
27424
27425 #if !defined(USE_STRUCT_CONVERSION)
27426
27427 static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectEXT(void *args)
27428 {
27429     struct vkCmdDrawMeshTasksIndirectEXT_params *params = args;
27430
27431     TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
27432
27433     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
27434     return STATUS_SUCCESS;
27435 }
27436
27437 #else /* USE_STRUCT_CONVERSION */
27438
27439 static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectEXT(void *args)
27440 {
27441     struct
27442     {
27443         VkCommandBuffer commandBuffer;
27444         VkBuffer DECLSPEC_ALIGN(8) buffer;
27445         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27446         uint32_t drawCount;
27447         uint32_t stride;
27448     } *params = args;
27449
27450     TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
27451
27452     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
27453     return STATUS_SUCCESS;
27454 }
27455
27456 #endif /* USE_STRUCT_CONVERSION */
27457
27458 #if !defined(USE_STRUCT_CONVERSION)
27459
27460 static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectNV(void *args)
27461 {
27462     struct vkCmdDrawMeshTasksIndirectNV_params *params = args;
27463
27464     TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
27465
27466     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
27467     return STATUS_SUCCESS;
27468 }
27469
27470 #else /* USE_STRUCT_CONVERSION */
27471
27472 static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectNV(void *args)
27473 {
27474     struct
27475     {
27476         VkCommandBuffer commandBuffer;
27477         VkBuffer DECLSPEC_ALIGN(8) buffer;
27478         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27479         uint32_t drawCount;
27480         uint32_t stride;
27481     } *params = args;
27482
27483     TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
27484
27485     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
27486     return STATUS_SUCCESS;
27487 }
27488
27489 #endif /* USE_STRUCT_CONVERSION */
27490
27491 #if !defined(USE_STRUCT_CONVERSION)
27492
27493 static NTSTATUS thunk64_vkCmdDrawMeshTasksNV(void *args)
27494 {
27495     struct vkCmdDrawMeshTasksNV_params *params = args;
27496
27497     TRACE("%p, %u, %u\n", params->commandBuffer, params->taskCount, params->firstTask);
27498
27499     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->taskCount, params->firstTask);
27500     return STATUS_SUCCESS;
27501 }
27502
27503 #else /* USE_STRUCT_CONVERSION */
27504
27505 static NTSTATUS thunk32_vkCmdDrawMeshTasksNV(void *args)
27506 {
27507     struct
27508     {
27509         VkCommandBuffer commandBuffer;
27510         uint32_t taskCount;
27511         uint32_t firstTask;
27512     } *params = args;
27513
27514     TRACE("%p, %u, %u\n", params->commandBuffer, params->taskCount, params->firstTask);
27515
27516     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->taskCount, params->firstTask);
27517     return STATUS_SUCCESS;
27518 }
27519
27520 #endif /* USE_STRUCT_CONVERSION */
27521
27522 #if !defined(USE_STRUCT_CONVERSION)
27523
27524 static NTSTATUS thunk64_vkCmdDrawMultiEXT(void *args)
27525 {
27526     struct vkCmdDrawMultiEXT_params *params = args;
27527
27528     TRACE("%p, %u, %p, %u, %u, %u\n", params->commandBuffer, params->drawCount, params->pVertexInfo, params->instanceCount, params->firstInstance, params->stride);
27529
27530     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMultiEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->drawCount, params->pVertexInfo, params->instanceCount, params->firstInstance, params->stride);
27531     return STATUS_SUCCESS;
27532 }
27533
27534 #else /* USE_STRUCT_CONVERSION */
27535
27536 static NTSTATUS thunk32_vkCmdDrawMultiEXT(void *args)
27537 {
27538     struct
27539     {
27540         VkCommandBuffer commandBuffer;
27541         uint32_t drawCount;
27542         const VkMultiDrawInfoEXT *pVertexInfo;
27543         uint32_t instanceCount;
27544         uint32_t firstInstance;
27545         uint32_t stride;
27546     } *params = args;
27547
27548     TRACE("%p, %u, %p, %u, %u, %u\n", params->commandBuffer, params->drawCount, params->pVertexInfo, params->instanceCount, params->firstInstance, params->stride);
27549
27550     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMultiEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->drawCount, params->pVertexInfo, params->instanceCount, params->firstInstance, params->stride);
27551     return STATUS_SUCCESS;
27552 }
27553
27554 #endif /* USE_STRUCT_CONVERSION */
27555
27556 #if !defined(USE_STRUCT_CONVERSION)
27557
27558 static NTSTATUS thunk64_vkCmdDrawMultiIndexedEXT(void *args)
27559 {
27560     struct vkCmdDrawMultiIndexedEXT_params *params = args;
27561
27562     TRACE("%p, %u, %p, %u, %u, %u, %p\n", params->commandBuffer, params->drawCount, params->pIndexInfo, params->instanceCount, params->firstInstance, params->stride, params->pVertexOffset);
27563
27564     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMultiIndexedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->drawCount, params->pIndexInfo, params->instanceCount, params->firstInstance, params->stride, params->pVertexOffset);
27565     return STATUS_SUCCESS;
27566 }
27567
27568 #else /* USE_STRUCT_CONVERSION */
27569
27570 static NTSTATUS thunk32_vkCmdDrawMultiIndexedEXT(void *args)
27571 {
27572     struct
27573     {
27574         VkCommandBuffer commandBuffer;
27575         uint32_t drawCount;
27576         const VkMultiDrawIndexedInfoEXT *pIndexInfo;
27577         uint32_t instanceCount;
27578         uint32_t firstInstance;
27579         uint32_t stride;
27580         const int32_t *pVertexOffset;
27581     } *params = args;
27582
27583     TRACE("%p, %u, %p, %u, %u, %u, %p\n", params->commandBuffer, params->drawCount, params->pIndexInfo, params->instanceCount, params->firstInstance, params->stride, params->pVertexOffset);
27584
27585     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMultiIndexedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->drawCount, params->pIndexInfo, params->instanceCount, params->firstInstance, params->stride, params->pVertexOffset);
27586     return STATUS_SUCCESS;
27587 }
27588
27589 #endif /* USE_STRUCT_CONVERSION */
27590
27591 #if !defined(USE_STRUCT_CONVERSION)
27592
27593 static NTSTATUS thunk64_vkCmdEndConditionalRenderingEXT(void *args)
27594 {
27595     struct vkCmdEndConditionalRenderingEXT_params *params = args;
27596
27597     TRACE("%p\n", params->commandBuffer);
27598
27599     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
27600     return STATUS_SUCCESS;
27601 }
27602
27603 #else /* USE_STRUCT_CONVERSION */
27604
27605 static NTSTATUS thunk32_vkCmdEndConditionalRenderingEXT(void *args)
27606 {
27607     struct
27608     {
27609         VkCommandBuffer commandBuffer;
27610     } *params = args;
27611
27612     TRACE("%p\n", params->commandBuffer);
27613
27614     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
27615     return STATUS_SUCCESS;
27616 }
27617
27618 #endif /* USE_STRUCT_CONVERSION */
27619
27620 #if !defined(USE_STRUCT_CONVERSION)
27621
27622 static NTSTATUS thunk64_vkCmdEndDebugUtilsLabelEXT(void *args)
27623 {
27624     struct vkCmdEndDebugUtilsLabelEXT_params *params = args;
27625
27626     TRACE("%p\n", params->commandBuffer);
27627
27628     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
27629     return STATUS_SUCCESS;
27630 }
27631
27632 #else /* USE_STRUCT_CONVERSION */
27633
27634 static NTSTATUS thunk32_vkCmdEndDebugUtilsLabelEXT(void *args)
27635 {
27636     struct
27637     {
27638         VkCommandBuffer commandBuffer;
27639     } *params = args;
27640
27641     TRACE("%p\n", params->commandBuffer);
27642
27643     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
27644     return STATUS_SUCCESS;
27645 }
27646
27647 #endif /* USE_STRUCT_CONVERSION */
27648
27649 #if !defined(USE_STRUCT_CONVERSION)
27650
27651 static NTSTATUS thunk64_vkCmdEndQuery(void *args)
27652 {
27653     struct vkCmdEndQuery_params *params = args;
27654
27655     TRACE("%p, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query);
27656
27657     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndQuery(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query);
27658     return STATUS_SUCCESS;
27659 }
27660
27661 #else /* USE_STRUCT_CONVERSION */
27662
27663 static NTSTATUS thunk32_vkCmdEndQuery(void *args)
27664 {
27665     struct
27666     {
27667         VkCommandBuffer commandBuffer;
27668         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
27669         uint32_t query;
27670     } *params = args;
27671
27672     TRACE("%p, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query);
27673
27674     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndQuery(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query);
27675     return STATUS_SUCCESS;
27676 }
27677
27678 #endif /* USE_STRUCT_CONVERSION */
27679
27680 #if !defined(USE_STRUCT_CONVERSION)
27681
27682 static NTSTATUS thunk64_vkCmdEndQueryIndexedEXT(void *args)
27683 {
27684     struct vkCmdEndQueryIndexedEXT_params *params = args;
27685
27686     TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->index);
27687
27688     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndQueryIndexedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query, params->index);
27689     return STATUS_SUCCESS;
27690 }
27691
27692 #else /* USE_STRUCT_CONVERSION */
27693
27694 static NTSTATUS thunk32_vkCmdEndQueryIndexedEXT(void *args)
27695 {
27696     struct
27697     {
27698         VkCommandBuffer commandBuffer;
27699         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
27700         uint32_t query;
27701         uint32_t index;
27702     } *params = args;
27703
27704     TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->index);
27705
27706     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndQueryIndexedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query, params->index);
27707     return STATUS_SUCCESS;
27708 }
27709
27710 #endif /* USE_STRUCT_CONVERSION */
27711
27712 #if !defined(USE_STRUCT_CONVERSION)
27713
27714 static NTSTATUS thunk64_vkCmdEndRenderPass(void *args)
27715 {
27716     struct vkCmdEndRenderPass_params *params = args;
27717
27718     TRACE("%p\n", params->commandBuffer);
27719
27720     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
27721     return STATUS_SUCCESS;
27722 }
27723
27724 #else /* USE_STRUCT_CONVERSION */
27725
27726 static NTSTATUS thunk32_vkCmdEndRenderPass(void *args)
27727 {
27728     struct
27729     {
27730         VkCommandBuffer commandBuffer;
27731     } *params = args;
27732
27733     TRACE("%p\n", params->commandBuffer);
27734
27735     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
27736     return STATUS_SUCCESS;
27737 }
27738
27739 #endif /* USE_STRUCT_CONVERSION */
27740
27741 #if !defined(USE_STRUCT_CONVERSION)
27742
27743 static NTSTATUS thunk64_vkCmdEndRenderPass2(void *args)
27744 {
27745     struct vkCmdEndRenderPass2_params *params = args;
27746
27747     TRACE("%p, %p\n", params->commandBuffer, params->pSubpassEndInfo);
27748
27749     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassEndInfo);
27750     return STATUS_SUCCESS;
27751 }
27752
27753 #else /* USE_STRUCT_CONVERSION */
27754
27755 static NTSTATUS thunk32_vkCmdEndRenderPass2(void *args)
27756 {
27757     struct
27758     {
27759         VkCommandBuffer commandBuffer;
27760         const VkSubpassEndInfo32 *pSubpassEndInfo;
27761     } *params = args;
27762     VkSubpassEndInfo pSubpassEndInfo_host;
27763     struct conversion_context ctx;
27764
27765     TRACE("%p, %p\n", params->commandBuffer, params->pSubpassEndInfo);
27766
27767     init_conversion_context(&ctx);
27768     convert_VkSubpassEndInfo_win32_to_host(&ctx, params->pSubpassEndInfo, &pSubpassEndInfo_host);
27769     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pSubpassEndInfo_host);
27770     free_conversion_context(&ctx);
27771     return STATUS_SUCCESS;
27772 }
27773
27774 #endif /* USE_STRUCT_CONVERSION */
27775
27776 #if !defined(USE_STRUCT_CONVERSION)
27777
27778 static NTSTATUS thunk64_vkCmdEndRenderPass2KHR(void *args)
27779 {
27780     struct vkCmdEndRenderPass2KHR_params *params = args;
27781
27782     TRACE("%p, %p\n", params->commandBuffer, params->pSubpassEndInfo);
27783
27784     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassEndInfo);
27785     return STATUS_SUCCESS;
27786 }
27787
27788 #else /* USE_STRUCT_CONVERSION */
27789
27790 static NTSTATUS thunk32_vkCmdEndRenderPass2KHR(void *args)
27791 {
27792     struct
27793     {
27794         VkCommandBuffer commandBuffer;
27795         const VkSubpassEndInfo32 *pSubpassEndInfo;
27796     } *params = args;
27797     VkSubpassEndInfo pSubpassEndInfo_host;
27798     struct conversion_context ctx;
27799
27800     TRACE("%p, %p\n", params->commandBuffer, params->pSubpassEndInfo);
27801
27802     init_conversion_context(&ctx);
27803     convert_VkSubpassEndInfo_win32_to_host(&ctx, params->pSubpassEndInfo, &pSubpassEndInfo_host);
27804     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pSubpassEndInfo_host);
27805     free_conversion_context(&ctx);
27806     return STATUS_SUCCESS;
27807 }
27808
27809 #endif /* USE_STRUCT_CONVERSION */
27810
27811 #if !defined(USE_STRUCT_CONVERSION)
27812
27813 static NTSTATUS thunk64_vkCmdEndRendering(void *args)
27814 {
27815     struct vkCmdEndRendering_params *params = args;
27816
27817     TRACE("%p\n", params->commandBuffer);
27818
27819     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
27820     return STATUS_SUCCESS;
27821 }
27822
27823 #else /* USE_STRUCT_CONVERSION */
27824
27825 static NTSTATUS thunk32_vkCmdEndRendering(void *args)
27826 {
27827     struct
27828     {
27829         VkCommandBuffer commandBuffer;
27830     } *params = args;
27831
27832     TRACE("%p\n", params->commandBuffer);
27833
27834     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
27835     return STATUS_SUCCESS;
27836 }
27837
27838 #endif /* USE_STRUCT_CONVERSION */
27839
27840 #if !defined(USE_STRUCT_CONVERSION)
27841
27842 static NTSTATUS thunk64_vkCmdEndRenderingKHR(void *args)
27843 {
27844     struct vkCmdEndRenderingKHR_params *params = args;
27845
27846     TRACE("%p\n", params->commandBuffer);
27847
27848     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
27849     return STATUS_SUCCESS;
27850 }
27851
27852 #else /* USE_STRUCT_CONVERSION */
27853
27854 static NTSTATUS thunk32_vkCmdEndRenderingKHR(void *args)
27855 {
27856     struct
27857     {
27858         VkCommandBuffer commandBuffer;
27859     } *params = args;
27860
27861     TRACE("%p\n", params->commandBuffer);
27862
27863     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
27864     return STATUS_SUCCESS;
27865 }
27866
27867 #endif /* USE_STRUCT_CONVERSION */
27868
27869 #if !defined(USE_STRUCT_CONVERSION)
27870
27871 static NTSTATUS thunk64_vkCmdEndTransformFeedbackEXT(void *args)
27872 {
27873     struct vkCmdEndTransformFeedbackEXT_params *params = args;
27874
27875     TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
27876
27877     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndTransformFeedbackEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
27878     return STATUS_SUCCESS;
27879 }
27880
27881 #else /* USE_STRUCT_CONVERSION */
27882
27883 static NTSTATUS thunk32_vkCmdEndTransformFeedbackEXT(void *args)
27884 {
27885     struct
27886     {
27887         VkCommandBuffer commandBuffer;
27888         uint32_t firstCounterBuffer;
27889         uint32_t counterBufferCount;
27890         const VkBuffer *pCounterBuffers;
27891         const VkDeviceSize *pCounterBufferOffsets;
27892     } *params = args;
27893
27894     TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
27895
27896     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndTransformFeedbackEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
27897     return STATUS_SUCCESS;
27898 }
27899
27900 #endif /* USE_STRUCT_CONVERSION */
27901
27902 #if !defined(USE_STRUCT_CONVERSION)
27903
27904 static NTSTATUS thunk64_vkCmdExecuteCommands(void *args)
27905 {
27906     struct vkCmdExecuteCommands_params *params = args;
27907     const VkCommandBuffer *pCommandBuffers_host;
27908     struct conversion_context ctx;
27909
27910     TRACE("%p, %u, %p\n", params->commandBuffer, params->commandBufferCount, params->pCommandBuffers);
27911
27912     init_conversion_context(&ctx);
27913     pCommandBuffers_host = convert_VkCommandBuffer_array_win64_to_host(&ctx, params->pCommandBuffers, params->commandBufferCount);
27914     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteCommands(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->commandBufferCount, pCommandBuffers_host);
27915     free_conversion_context(&ctx);
27916     return STATUS_SUCCESS;
27917 }
27918
27919 #else /* USE_STRUCT_CONVERSION */
27920
27921 static NTSTATUS thunk32_vkCmdExecuteCommands(void *args)
27922 {
27923     struct
27924     {
27925         VkCommandBuffer commandBuffer;
27926         uint32_t commandBufferCount;
27927         const VkCommandBuffer *pCommandBuffers;
27928     } *params = args;
27929     const VkCommandBuffer *pCommandBuffers_host;
27930     struct conversion_context ctx;
27931
27932     TRACE("%p, %u, %p\n", params->commandBuffer, params->commandBufferCount, params->pCommandBuffers);
27933
27934     init_conversion_context(&ctx);
27935     pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_host(&ctx, params->pCommandBuffers, params->commandBufferCount);
27936     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteCommands(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->commandBufferCount, pCommandBuffers_host);
27937     free_conversion_context(&ctx);
27938     return STATUS_SUCCESS;
27939 }
27940
27941 #endif /* USE_STRUCT_CONVERSION */
27942
27943 #if !defined(USE_STRUCT_CONVERSION)
27944
27945 static NTSTATUS thunk64_vkCmdExecuteGeneratedCommandsNV(void *args)
27946 {
27947     struct vkCmdExecuteGeneratedCommandsNV_params *params = args;
27948
27949     TRACE("%p, %u, %p\n", params->commandBuffer, params->isPreprocessed, params->pGeneratedCommandsInfo);
27950
27951     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->isPreprocessed, params->pGeneratedCommandsInfo);
27952     return STATUS_SUCCESS;
27953 }
27954
27955 #else /* USE_STRUCT_CONVERSION */
27956
27957 static NTSTATUS thunk32_vkCmdExecuteGeneratedCommandsNV(void *args)
27958 {
27959     struct
27960     {
27961         VkCommandBuffer commandBuffer;
27962         VkBool32 isPreprocessed;
27963         const VkGeneratedCommandsInfoNV32 *pGeneratedCommandsInfo;
27964     } *params = args;
27965     VkGeneratedCommandsInfoNV pGeneratedCommandsInfo_host;
27966     struct conversion_context ctx;
27967
27968     TRACE("%p, %u, %p\n", params->commandBuffer, params->isPreprocessed, params->pGeneratedCommandsInfo);
27969
27970     init_conversion_context(&ctx);
27971     convert_VkGeneratedCommandsInfoNV_win32_to_host(&ctx, params->pGeneratedCommandsInfo, &pGeneratedCommandsInfo_host);
27972     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->isPreprocessed, &pGeneratedCommandsInfo_host);
27973     free_conversion_context(&ctx);
27974     return STATUS_SUCCESS;
27975 }
27976
27977 #endif /* USE_STRUCT_CONVERSION */
27978
27979 #if !defined(USE_STRUCT_CONVERSION)
27980
27981 static NTSTATUS thunk64_vkCmdFillBuffer(void *args)
27982 {
27983     struct vkCmdFillBuffer_params *params = args;
27984
27985     TRACE("%p, 0x%s, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->size), params->data);
27986
27987     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdFillBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->dstBuffer, params->dstOffset, params->size, params->data);
27988     return STATUS_SUCCESS;
27989 }
27990
27991 #else /* USE_STRUCT_CONVERSION */
27992
27993 static NTSTATUS thunk32_vkCmdFillBuffer(void *args)
27994 {
27995     struct
27996     {
27997         VkCommandBuffer commandBuffer;
27998         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
27999         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
28000         VkDeviceSize DECLSPEC_ALIGN(8) size;
28001         uint32_t data;
28002     } *params = args;
28003
28004     TRACE("%p, 0x%s, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->size), params->data);
28005
28006     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdFillBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->dstBuffer, params->dstOffset, params->size, params->data);
28007     return STATUS_SUCCESS;
28008 }
28009
28010 #endif /* USE_STRUCT_CONVERSION */
28011
28012 #if !defined(USE_STRUCT_CONVERSION)
28013
28014 static NTSTATUS thunk64_vkCmdInsertDebugUtilsLabelEXT(void *args)
28015 {
28016     struct vkCmdInsertDebugUtilsLabelEXT_params *params = args;
28017
28018     TRACE("%p, %p\n", params->commandBuffer, params->pLabelInfo);
28019
28020     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdInsertDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLabelInfo);
28021     return STATUS_SUCCESS;
28022 }
28023
28024 #else /* USE_STRUCT_CONVERSION */
28025
28026 static NTSTATUS thunk32_vkCmdInsertDebugUtilsLabelEXT(void *args)
28027 {
28028     struct
28029     {
28030         VkCommandBuffer commandBuffer;
28031         const VkDebugUtilsLabelEXT32 *pLabelInfo;
28032     } *params = args;
28033     VkDebugUtilsLabelEXT pLabelInfo_host;
28034
28035     TRACE("%p, %p\n", params->commandBuffer, params->pLabelInfo);
28036
28037     convert_VkDebugUtilsLabelEXT_win32_to_host(params->pLabelInfo, &pLabelInfo_host);
28038     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdInsertDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pLabelInfo_host);
28039     return STATUS_SUCCESS;
28040 }
28041
28042 #endif /* USE_STRUCT_CONVERSION */
28043
28044 #if !defined(USE_STRUCT_CONVERSION)
28045
28046 static NTSTATUS thunk64_vkCmdNextSubpass(void *args)
28047 {
28048     struct vkCmdNextSubpass_params *params = args;
28049
28050     TRACE("%p, %#x\n", params->commandBuffer, params->contents);
28051
28052     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->contents);
28053     return STATUS_SUCCESS;
28054 }
28055
28056 #else /* USE_STRUCT_CONVERSION */
28057
28058 static NTSTATUS thunk32_vkCmdNextSubpass(void *args)
28059 {
28060     struct
28061     {
28062         VkCommandBuffer commandBuffer;
28063         VkSubpassContents contents;
28064     } *params = args;
28065
28066     TRACE("%p, %#x\n", params->commandBuffer, params->contents);
28067
28068     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->contents);
28069     return STATUS_SUCCESS;
28070 }
28071
28072 #endif /* USE_STRUCT_CONVERSION */
28073
28074 #if !defined(USE_STRUCT_CONVERSION)
28075
28076 static NTSTATUS thunk64_vkCmdNextSubpass2(void *args)
28077 {
28078     struct vkCmdNextSubpass2_params *params = args;
28079
28080     TRACE("%p, %p, %p\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
28081
28082     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
28083     return STATUS_SUCCESS;
28084 }
28085
28086 #else /* USE_STRUCT_CONVERSION */
28087
28088 static NTSTATUS thunk32_vkCmdNextSubpass2(void *args)
28089 {
28090     struct
28091     {
28092         VkCommandBuffer commandBuffer;
28093         const VkSubpassBeginInfo32 *pSubpassBeginInfo;
28094         const VkSubpassEndInfo32 *pSubpassEndInfo;
28095     } *params = args;
28096     VkSubpassBeginInfo pSubpassBeginInfo_host;
28097     VkSubpassEndInfo pSubpassEndInfo_host;
28098     struct conversion_context ctx;
28099
28100     TRACE("%p, %p, %p\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
28101
28102     init_conversion_context(&ctx);
28103     convert_VkSubpassBeginInfo_win32_to_host(params->pSubpassBeginInfo, &pSubpassBeginInfo_host);
28104     convert_VkSubpassEndInfo_win32_to_host(&ctx, params->pSubpassEndInfo, &pSubpassEndInfo_host);
28105     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pSubpassBeginInfo_host, &pSubpassEndInfo_host);
28106     free_conversion_context(&ctx);
28107     return STATUS_SUCCESS;
28108 }
28109
28110 #endif /* USE_STRUCT_CONVERSION */
28111
28112 #if !defined(USE_STRUCT_CONVERSION)
28113
28114 static NTSTATUS thunk64_vkCmdNextSubpass2KHR(void *args)
28115 {
28116     struct vkCmdNextSubpass2KHR_params *params = args;
28117
28118     TRACE("%p, %p, %p\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
28119
28120     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
28121     return STATUS_SUCCESS;
28122 }
28123
28124 #else /* USE_STRUCT_CONVERSION */
28125
28126 static NTSTATUS thunk32_vkCmdNextSubpass2KHR(void *args)
28127 {
28128     struct
28129     {
28130         VkCommandBuffer commandBuffer;
28131         const VkSubpassBeginInfo32 *pSubpassBeginInfo;
28132         const VkSubpassEndInfo32 *pSubpassEndInfo;
28133     } *params = args;
28134     VkSubpassBeginInfo pSubpassBeginInfo_host;
28135     VkSubpassEndInfo pSubpassEndInfo_host;
28136     struct conversion_context ctx;
28137
28138     TRACE("%p, %p, %p\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
28139
28140     init_conversion_context(&ctx);
28141     convert_VkSubpassBeginInfo_win32_to_host(params->pSubpassBeginInfo, &pSubpassBeginInfo_host);
28142     convert_VkSubpassEndInfo_win32_to_host(&ctx, params->pSubpassEndInfo, &pSubpassEndInfo_host);
28143     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pSubpassBeginInfo_host, &pSubpassEndInfo_host);
28144     free_conversion_context(&ctx);
28145     return STATUS_SUCCESS;
28146 }
28147
28148 #endif /* USE_STRUCT_CONVERSION */
28149
28150 #if !defined(USE_STRUCT_CONVERSION)
28151
28152 static NTSTATUS thunk64_vkCmdOpticalFlowExecuteNV(void *args)
28153 {
28154     struct vkCmdOpticalFlowExecuteNV_params *params = args;
28155
28156     TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->session), params->pExecuteInfo);
28157
28158     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdOpticalFlowExecuteNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->session, params->pExecuteInfo);
28159     return STATUS_SUCCESS;
28160 }
28161
28162 #else /* USE_STRUCT_CONVERSION */
28163
28164 static NTSTATUS thunk32_vkCmdOpticalFlowExecuteNV(void *args)
28165 {
28166     struct
28167     {
28168         VkCommandBuffer commandBuffer;
28169         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
28170         const VkOpticalFlowExecuteInfoNV32 *pExecuteInfo;
28171     } *params = args;
28172     VkOpticalFlowExecuteInfoNV pExecuteInfo_host;
28173
28174     TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->session), params->pExecuteInfo);
28175
28176     convert_VkOpticalFlowExecuteInfoNV_win32_to_host(params->pExecuteInfo, &pExecuteInfo_host);
28177     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdOpticalFlowExecuteNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->session, &pExecuteInfo_host);
28178     return STATUS_SUCCESS;
28179 }
28180
28181 #endif /* USE_STRUCT_CONVERSION */
28182
28183 #if !defined(USE_STRUCT_CONVERSION)
28184
28185 static NTSTATUS thunk64_vkCmdPipelineBarrier(void *args)
28186 {
28187     struct vkCmdPipelineBarrier_params *params = args;
28188
28189     TRACE("%p, %#x, %#x, %#x, %u, %p, %u, %p, %u, %p\n", params->commandBuffer, params->srcStageMask, params->dstStageMask, params->dependencyFlags, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
28190
28191     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcStageMask, params->dstStageMask, params->dependencyFlags, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
28192     return STATUS_SUCCESS;
28193 }
28194
28195 #else /* USE_STRUCT_CONVERSION */
28196
28197 static NTSTATUS thunk32_vkCmdPipelineBarrier(void *args)
28198 {
28199     struct
28200     {
28201         VkCommandBuffer commandBuffer;
28202         VkPipelineStageFlags srcStageMask;
28203         VkPipelineStageFlags dstStageMask;
28204         VkDependencyFlags dependencyFlags;
28205         uint32_t memoryBarrierCount;
28206         const VkMemoryBarrier32 *pMemoryBarriers;
28207         uint32_t bufferMemoryBarrierCount;
28208         const VkBufferMemoryBarrier32 *pBufferMemoryBarriers;
28209         uint32_t imageMemoryBarrierCount;
28210         const VkImageMemoryBarrier32 *pImageMemoryBarriers;
28211     } *params = args;
28212     const VkMemoryBarrier *pMemoryBarriers_host;
28213     const VkBufferMemoryBarrier *pBufferMemoryBarriers_host;
28214     const VkImageMemoryBarrier *pImageMemoryBarriers_host;
28215     struct conversion_context ctx;
28216
28217     TRACE("%p, %#x, %#x, %#x, %u, %p, %u, %p, %u, %p\n", params->commandBuffer, params->srcStageMask, params->dstStageMask, params->dependencyFlags, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
28218
28219     init_conversion_context(&ctx);
28220     pMemoryBarriers_host = convert_VkMemoryBarrier_array_win32_to_host(&ctx, params->pMemoryBarriers, params->memoryBarrierCount);
28221     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win32_to_host(&ctx, params->pBufferMemoryBarriers, params->bufferMemoryBarrierCount);
28222     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win32_to_host(&ctx, params->pImageMemoryBarriers, params->imageMemoryBarrierCount);
28223     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcStageMask, params->dstStageMask, params->dependencyFlags, params->memoryBarrierCount, pMemoryBarriers_host, params->bufferMemoryBarrierCount, pBufferMemoryBarriers_host, params->imageMemoryBarrierCount, pImageMemoryBarriers_host);
28224     free_conversion_context(&ctx);
28225     return STATUS_SUCCESS;
28226 }
28227
28228 #endif /* USE_STRUCT_CONVERSION */
28229
28230 #if !defined(USE_STRUCT_CONVERSION)
28231
28232 static NTSTATUS thunk64_vkCmdPipelineBarrier2(void *args)
28233 {
28234     struct vkCmdPipelineBarrier2_params *params = args;
28235
28236     TRACE("%p, %p\n", params->commandBuffer, params->pDependencyInfo);
28237
28238     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pDependencyInfo);
28239     return STATUS_SUCCESS;
28240 }
28241
28242 #else /* USE_STRUCT_CONVERSION */
28243
28244 static NTSTATUS thunk32_vkCmdPipelineBarrier2(void *args)
28245 {
28246     struct
28247     {
28248         VkCommandBuffer commandBuffer;
28249         const VkDependencyInfo32 *pDependencyInfo;
28250     } *params = args;
28251     VkDependencyInfo pDependencyInfo_host;
28252     struct conversion_context ctx;
28253
28254     TRACE("%p, %p\n", params->commandBuffer, params->pDependencyInfo);
28255
28256     init_conversion_context(&ctx);
28257     convert_VkDependencyInfo_win32_to_host(&ctx, params->pDependencyInfo, &pDependencyInfo_host);
28258     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pDependencyInfo_host);
28259     free_conversion_context(&ctx);
28260     return STATUS_SUCCESS;
28261 }
28262
28263 #endif /* USE_STRUCT_CONVERSION */
28264
28265 #if !defined(USE_STRUCT_CONVERSION)
28266
28267 static NTSTATUS thunk64_vkCmdPipelineBarrier2KHR(void *args)
28268 {
28269     struct vkCmdPipelineBarrier2KHR_params *params = args;
28270
28271     TRACE("%p, %p\n", params->commandBuffer, params->pDependencyInfo);
28272
28273     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pDependencyInfo);
28274     return STATUS_SUCCESS;
28275 }
28276
28277 #else /* USE_STRUCT_CONVERSION */
28278
28279 static NTSTATUS thunk32_vkCmdPipelineBarrier2KHR(void *args)
28280 {
28281     struct
28282     {
28283         VkCommandBuffer commandBuffer;
28284         const VkDependencyInfo32 *pDependencyInfo;
28285     } *params = args;
28286     VkDependencyInfo pDependencyInfo_host;
28287     struct conversion_context ctx;
28288
28289     TRACE("%p, %p\n", params->commandBuffer, params->pDependencyInfo);
28290
28291     init_conversion_context(&ctx);
28292     convert_VkDependencyInfo_win32_to_host(&ctx, params->pDependencyInfo, &pDependencyInfo_host);
28293     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pDependencyInfo_host);
28294     free_conversion_context(&ctx);
28295     return STATUS_SUCCESS;
28296 }
28297
28298 #endif /* USE_STRUCT_CONVERSION */
28299
28300 #if !defined(USE_STRUCT_CONVERSION)
28301
28302 static NTSTATUS thunk64_vkCmdPreprocessGeneratedCommandsNV(void *args)
28303 {
28304     struct vkCmdPreprocessGeneratedCommandsNV_params *params = args;
28305
28306     TRACE("%p, %p\n", params->commandBuffer, params->pGeneratedCommandsInfo);
28307
28308     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPreprocessGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pGeneratedCommandsInfo);
28309     return STATUS_SUCCESS;
28310 }
28311
28312 #else /* USE_STRUCT_CONVERSION */
28313
28314 static NTSTATUS thunk32_vkCmdPreprocessGeneratedCommandsNV(void *args)
28315 {
28316     struct
28317     {
28318         VkCommandBuffer commandBuffer;
28319         const VkGeneratedCommandsInfoNV32 *pGeneratedCommandsInfo;
28320     } *params = args;
28321     VkGeneratedCommandsInfoNV pGeneratedCommandsInfo_host;
28322     struct conversion_context ctx;
28323
28324     TRACE("%p, %p\n", params->commandBuffer, params->pGeneratedCommandsInfo);
28325
28326     init_conversion_context(&ctx);
28327     convert_VkGeneratedCommandsInfoNV_win32_to_host(&ctx, params->pGeneratedCommandsInfo, &pGeneratedCommandsInfo_host);
28328     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPreprocessGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pGeneratedCommandsInfo_host);
28329     free_conversion_context(&ctx);
28330     return STATUS_SUCCESS;
28331 }
28332
28333 #endif /* USE_STRUCT_CONVERSION */
28334
28335 #if !defined(USE_STRUCT_CONVERSION)
28336
28337 static NTSTATUS thunk64_vkCmdPushConstants(void *args)
28338 {
28339     struct vkCmdPushConstants_params *params = args;
28340
28341     TRACE("%p, 0x%s, %#x, %u, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->layout), params->stageFlags, params->offset, params->size, params->pValues);
28342
28343     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPushConstants(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->layout, params->stageFlags, params->offset, params->size, params->pValues);
28344     return STATUS_SUCCESS;
28345 }
28346
28347 #else /* USE_STRUCT_CONVERSION */
28348
28349 static NTSTATUS thunk32_vkCmdPushConstants(void *args)
28350 {
28351     struct
28352     {
28353         VkCommandBuffer commandBuffer;
28354         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
28355         VkShaderStageFlags stageFlags;
28356         uint32_t offset;
28357         uint32_t size;
28358         const void *pValues;
28359     } *params = args;
28360
28361     TRACE("%p, 0x%s, %#x, %u, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->layout), params->stageFlags, params->offset, params->size, params->pValues);
28362
28363     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPushConstants(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->layout, params->stageFlags, params->offset, params->size, params->pValues);
28364     return STATUS_SUCCESS;
28365 }
28366
28367 #endif /* USE_STRUCT_CONVERSION */
28368
28369 #if !defined(USE_STRUCT_CONVERSION)
28370
28371 static NTSTATUS thunk64_vkCmdPushDescriptorSetKHR(void *args)
28372 {
28373     struct vkCmdPushDescriptorSetKHR_params *params = args;
28374
28375     TRACE("%p, %#x, 0x%s, %u, %u, %p\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->set, params->descriptorWriteCount, params->pDescriptorWrites);
28376
28377     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPushDescriptorSetKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->layout, params->set, params->descriptorWriteCount, params->pDescriptorWrites);
28378     return STATUS_SUCCESS;
28379 }
28380
28381 #else /* USE_STRUCT_CONVERSION */
28382
28383 static NTSTATUS thunk32_vkCmdPushDescriptorSetKHR(void *args)
28384 {
28385     struct
28386     {
28387         VkCommandBuffer commandBuffer;
28388         VkPipelineBindPoint pipelineBindPoint;
28389         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
28390         uint32_t set;
28391         uint32_t descriptorWriteCount;
28392         const VkWriteDescriptorSet32 *pDescriptorWrites;
28393     } *params = args;
28394     const VkWriteDescriptorSet *pDescriptorWrites_host;
28395     struct conversion_context ctx;
28396
28397     TRACE("%p, %#x, 0x%s, %u, %u, %p\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->set, params->descriptorWriteCount, params->pDescriptorWrites);
28398
28399     init_conversion_context(&ctx);
28400     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win32_to_host(&ctx, params->pDescriptorWrites, params->descriptorWriteCount);
28401     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPushDescriptorSetKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->layout, params->set, params->descriptorWriteCount, pDescriptorWrites_host);
28402     free_conversion_context(&ctx);
28403     return STATUS_SUCCESS;
28404 }
28405
28406 #endif /* USE_STRUCT_CONVERSION */
28407
28408 #if !defined(USE_STRUCT_CONVERSION)
28409
28410 static NTSTATUS thunk64_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
28411 {
28412     struct vkCmdPushDescriptorSetWithTemplateKHR_params *params = args;
28413
28414     TRACE("%p, 0x%s, 0x%s, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->descriptorUpdateTemplate), wine_dbgstr_longlong(params->layout), params->set, params->pData);
28415
28416     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPushDescriptorSetWithTemplateKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->descriptorUpdateTemplate, params->layout, params->set, params->pData);
28417     return STATUS_SUCCESS;
28418 }
28419
28420 #else /* USE_STRUCT_CONVERSION */
28421
28422 static NTSTATUS thunk32_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
28423 {
28424     struct
28425     {
28426         VkCommandBuffer commandBuffer;
28427         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
28428         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
28429         uint32_t set;
28430         const void *pData;
28431     } *params = args;
28432
28433     TRACE("%p, 0x%s, 0x%s, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->descriptorUpdateTemplate), wine_dbgstr_longlong(params->layout), params->set, params->pData);
28434
28435     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPushDescriptorSetWithTemplateKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->descriptorUpdateTemplate, params->layout, params->set, params->pData);
28436     return STATUS_SUCCESS;
28437 }
28438
28439 #endif /* USE_STRUCT_CONVERSION */
28440
28441 #if !defined(USE_STRUCT_CONVERSION)
28442
28443 static NTSTATUS thunk64_vkCmdResetEvent(void *args)
28444 {
28445     struct vkCmdResetEvent_params *params = args;
28446
28447     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);
28448
28449     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
28450     return STATUS_SUCCESS;
28451 }
28452
28453 #else /* USE_STRUCT_CONVERSION */
28454
28455 static NTSTATUS thunk32_vkCmdResetEvent(void *args)
28456 {
28457     struct
28458     {
28459         VkCommandBuffer commandBuffer;
28460         VkEvent DECLSPEC_ALIGN(8) event;
28461         VkPipelineStageFlags stageMask;
28462     } *params = args;
28463
28464     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);
28465
28466     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
28467     return STATUS_SUCCESS;
28468 }
28469
28470 #endif /* USE_STRUCT_CONVERSION */
28471
28472 #if !defined(USE_STRUCT_CONVERSION)
28473
28474 static NTSTATUS thunk64_vkCmdResetEvent2(void *args)
28475 {
28476     struct vkCmdResetEvent2_params *params = args;
28477
28478     TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));
28479
28480     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
28481     return STATUS_SUCCESS;
28482 }
28483
28484 #else /* USE_STRUCT_CONVERSION */
28485
28486 static NTSTATUS thunk32_vkCmdResetEvent2(void *args)
28487 {
28488     struct
28489     {
28490         VkCommandBuffer commandBuffer;
28491         VkEvent DECLSPEC_ALIGN(8) event;
28492         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
28493     } *params = args;
28494
28495     TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));
28496
28497     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
28498     return STATUS_SUCCESS;
28499 }
28500
28501 #endif /* USE_STRUCT_CONVERSION */
28502
28503 #if !defined(USE_STRUCT_CONVERSION)
28504
28505 static NTSTATUS thunk64_vkCmdResetEvent2KHR(void *args)
28506 {
28507     struct vkCmdResetEvent2KHR_params *params = args;
28508
28509     TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));
28510
28511     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
28512     return STATUS_SUCCESS;
28513 }
28514
28515 #else /* USE_STRUCT_CONVERSION */
28516
28517 static NTSTATUS thunk32_vkCmdResetEvent2KHR(void *args)
28518 {
28519     struct
28520     {
28521         VkCommandBuffer commandBuffer;
28522         VkEvent DECLSPEC_ALIGN(8) event;
28523         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
28524     } *params = args;
28525
28526     TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));
28527
28528     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
28529     return STATUS_SUCCESS;
28530 }
28531
28532 #endif /* USE_STRUCT_CONVERSION */
28533
28534 #if !defined(USE_STRUCT_CONVERSION)
28535
28536 static NTSTATUS thunk64_vkCmdResetQueryPool(void *args)
28537 {
28538     struct vkCmdResetQueryPool_params *params = args;
28539
28540     TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
28541
28542     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetQueryPool(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->firstQuery, params->queryCount);
28543     return STATUS_SUCCESS;
28544 }
28545
28546 #else /* USE_STRUCT_CONVERSION */
28547
28548 static NTSTATUS thunk32_vkCmdResetQueryPool(void *args)
28549 {
28550     struct
28551     {
28552         VkCommandBuffer commandBuffer;
28553         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
28554         uint32_t firstQuery;
28555         uint32_t queryCount;
28556     } *params = args;
28557
28558     TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
28559
28560     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetQueryPool(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->firstQuery, params->queryCount);
28561     return STATUS_SUCCESS;
28562 }
28563
28564 #endif /* USE_STRUCT_CONVERSION */
28565
28566 #if !defined(USE_STRUCT_CONVERSION)
28567
28568 static NTSTATUS thunk64_vkCmdResolveImage(void *args)
28569 {
28570     struct vkCmdResolveImage_params *params = args;
28571
28572     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
28573
28574     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, params->pRegions);
28575     return STATUS_SUCCESS;
28576 }
28577
28578 #else /* USE_STRUCT_CONVERSION */
28579
28580 static NTSTATUS thunk32_vkCmdResolveImage(void *args)
28581 {
28582     struct
28583     {
28584         VkCommandBuffer commandBuffer;
28585         VkImage DECLSPEC_ALIGN(8) srcImage;
28586         VkImageLayout srcImageLayout;
28587         VkImage DECLSPEC_ALIGN(8) dstImage;
28588         VkImageLayout dstImageLayout;
28589         uint32_t regionCount;
28590         const VkImageResolve *pRegions;
28591     } *params = args;
28592
28593     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
28594
28595     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, params->pRegions);
28596     return STATUS_SUCCESS;
28597 }
28598
28599 #endif /* USE_STRUCT_CONVERSION */
28600
28601 #if !defined(USE_STRUCT_CONVERSION)
28602
28603 static NTSTATUS thunk64_vkCmdResolveImage2(void *args)
28604 {
28605     struct vkCmdResolveImage2_params *params = args;
28606
28607     TRACE("%p, %p\n", params->commandBuffer, params->pResolveImageInfo);
28608
28609     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pResolveImageInfo);
28610     return STATUS_SUCCESS;
28611 }
28612
28613 #else /* USE_STRUCT_CONVERSION */
28614
28615 static NTSTATUS thunk32_vkCmdResolveImage2(void *args)
28616 {
28617     struct
28618     {
28619         VkCommandBuffer commandBuffer;
28620         const VkResolveImageInfo232 *pResolveImageInfo;
28621     } *params = args;
28622     VkResolveImageInfo2 pResolveImageInfo_host;
28623     struct conversion_context ctx;
28624
28625     TRACE("%p, %p\n", params->commandBuffer, params->pResolveImageInfo);
28626
28627     init_conversion_context(&ctx);
28628     convert_VkResolveImageInfo2_win32_to_host(&ctx, params->pResolveImageInfo, &pResolveImageInfo_host);
28629     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pResolveImageInfo_host);
28630     free_conversion_context(&ctx);
28631     return STATUS_SUCCESS;
28632 }
28633
28634 #endif /* USE_STRUCT_CONVERSION */
28635
28636 #if !defined(USE_STRUCT_CONVERSION)
28637
28638 static NTSTATUS thunk64_vkCmdResolveImage2KHR(void *args)
28639 {
28640     struct vkCmdResolveImage2KHR_params *params = args;
28641
28642     TRACE("%p, %p\n", params->commandBuffer, params->pResolveImageInfo);
28643
28644     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pResolveImageInfo);
28645     return STATUS_SUCCESS;
28646 }
28647
28648 #else /* USE_STRUCT_CONVERSION */
28649
28650 static NTSTATUS thunk32_vkCmdResolveImage2KHR(void *args)
28651 {
28652     struct
28653     {
28654         VkCommandBuffer commandBuffer;
28655         const VkResolveImageInfo232 *pResolveImageInfo;
28656     } *params = args;
28657     VkResolveImageInfo2 pResolveImageInfo_host;
28658     struct conversion_context ctx;
28659
28660     TRACE("%p, %p\n", params->commandBuffer, params->pResolveImageInfo);
28661
28662     init_conversion_context(&ctx);
28663     convert_VkResolveImageInfo2_win32_to_host(&ctx, params->pResolveImageInfo, &pResolveImageInfo_host);
28664     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pResolveImageInfo_host);
28665     free_conversion_context(&ctx);
28666     return STATUS_SUCCESS;
28667 }
28668
28669 #endif /* USE_STRUCT_CONVERSION */
28670
28671 #if !defined(USE_STRUCT_CONVERSION)
28672
28673 static NTSTATUS thunk64_vkCmdSetAlphaToCoverageEnableEXT(void *args)
28674 {
28675     struct vkCmdSetAlphaToCoverageEnableEXT_params *params = args;
28676
28677     TRACE("%p, %u\n", params->commandBuffer, params->alphaToCoverageEnable);
28678
28679     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToCoverageEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToCoverageEnable);
28680     return STATUS_SUCCESS;
28681 }
28682
28683 #else /* USE_STRUCT_CONVERSION */
28684
28685 static NTSTATUS thunk32_vkCmdSetAlphaToCoverageEnableEXT(void *args)
28686 {
28687     struct
28688     {
28689         VkCommandBuffer commandBuffer;
28690         VkBool32 alphaToCoverageEnable;
28691     } *params = args;
28692
28693     TRACE("%p, %u\n", params->commandBuffer, params->alphaToCoverageEnable);
28694
28695     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToCoverageEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToCoverageEnable);
28696     return STATUS_SUCCESS;
28697 }
28698
28699 #endif /* USE_STRUCT_CONVERSION */
28700
28701 #if !defined(USE_STRUCT_CONVERSION)
28702
28703 static NTSTATUS thunk64_vkCmdSetAlphaToOneEnableEXT(void *args)
28704 {
28705     struct vkCmdSetAlphaToOneEnableEXT_params *params = args;
28706
28707     TRACE("%p, %u\n", params->commandBuffer, params->alphaToOneEnable);
28708
28709     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToOneEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToOneEnable);
28710     return STATUS_SUCCESS;
28711 }
28712
28713 #else /* USE_STRUCT_CONVERSION */
28714
28715 static NTSTATUS thunk32_vkCmdSetAlphaToOneEnableEXT(void *args)
28716 {
28717     struct
28718     {
28719         VkCommandBuffer commandBuffer;
28720         VkBool32 alphaToOneEnable;
28721     } *params = args;
28722
28723     TRACE("%p, %u\n", params->commandBuffer, params->alphaToOneEnable);
28724
28725     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToOneEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToOneEnable);
28726     return STATUS_SUCCESS;
28727 }
28728
28729 #endif /* USE_STRUCT_CONVERSION */
28730
28731 #if !defined(USE_STRUCT_CONVERSION)
28732
28733 static NTSTATUS thunk64_vkCmdSetBlendConstants(void *args)
28734 {
28735     struct vkCmdSetBlendConstants_params *params = args;
28736
28737     TRACE("%p, %p\n", params->commandBuffer, params->blendConstants);
28738
28739     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetBlendConstants(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->blendConstants);
28740     return STATUS_SUCCESS;
28741 }
28742
28743 #else /* USE_STRUCT_CONVERSION */
28744
28745 static NTSTATUS thunk32_vkCmdSetBlendConstants(void *args)
28746 {
28747     struct
28748     {
28749         VkCommandBuffer commandBuffer;
28750         const float *blendConstants;
28751     } *params = args;
28752
28753     TRACE("%p, %p\n", params->commandBuffer, params->blendConstants);
28754
28755     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetBlendConstants(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->blendConstants);
28756     return STATUS_SUCCESS;
28757 }
28758
28759 #endif /* USE_STRUCT_CONVERSION */
28760
28761 #if !defined(USE_STRUCT_CONVERSION)
28762
28763 static NTSTATUS thunk64_vkCmdSetCheckpointNV(void *args)
28764 {
28765     struct vkCmdSetCheckpointNV_params *params = args;
28766
28767     TRACE("%p, %p\n", params->commandBuffer, params->pCheckpointMarker);
28768
28769     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCheckpointNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCheckpointMarker);
28770     return STATUS_SUCCESS;
28771 }
28772
28773 #else /* USE_STRUCT_CONVERSION */
28774
28775 static NTSTATUS thunk32_vkCmdSetCheckpointNV(void *args)
28776 {
28777     struct
28778     {
28779         VkCommandBuffer commandBuffer;
28780         const void *pCheckpointMarker;
28781     } *params = args;
28782
28783     TRACE("%p, %p\n", params->commandBuffer, params->pCheckpointMarker);
28784
28785     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCheckpointNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCheckpointMarker);
28786     return STATUS_SUCCESS;
28787 }
28788
28789 #endif /* USE_STRUCT_CONVERSION */
28790
28791 #if !defined(USE_STRUCT_CONVERSION)
28792
28793 static NTSTATUS thunk64_vkCmdSetCoarseSampleOrderNV(void *args)
28794 {
28795     struct vkCmdSetCoarseSampleOrderNV_params *params = args;
28796
28797     TRACE("%p, %#x, %u, %p\n", params->commandBuffer, params->sampleOrderType, params->customSampleOrderCount, params->pCustomSampleOrders);
28798
28799     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoarseSampleOrderNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->sampleOrderType, params->customSampleOrderCount, params->pCustomSampleOrders);
28800     return STATUS_SUCCESS;
28801 }
28802
28803 #else /* USE_STRUCT_CONVERSION */
28804
28805 static NTSTATUS thunk32_vkCmdSetCoarseSampleOrderNV(void *args)
28806 {
28807     struct
28808     {
28809         VkCommandBuffer commandBuffer;
28810         VkCoarseSampleOrderTypeNV sampleOrderType;
28811         uint32_t customSampleOrderCount;
28812         const VkCoarseSampleOrderCustomNV *pCustomSampleOrders;
28813     } *params = args;
28814
28815     TRACE("%p, %#x, %u, %p\n", params->commandBuffer, params->sampleOrderType, params->customSampleOrderCount, params->pCustomSampleOrders);
28816
28817     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoarseSampleOrderNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->sampleOrderType, params->customSampleOrderCount, params->pCustomSampleOrders);
28818     return STATUS_SUCCESS;
28819 }
28820
28821 #endif /* USE_STRUCT_CONVERSION */
28822
28823 #if !defined(USE_STRUCT_CONVERSION)
28824
28825 static NTSTATUS thunk64_vkCmdSetColorBlendAdvancedEXT(void *args)
28826 {
28827     struct vkCmdSetColorBlendAdvancedEXT_params *params = args;
28828
28829     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendAdvanced);
28830
28831     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendAdvancedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendAdvanced);
28832     return STATUS_SUCCESS;
28833 }
28834
28835 #else /* USE_STRUCT_CONVERSION */
28836
28837 static NTSTATUS thunk32_vkCmdSetColorBlendAdvancedEXT(void *args)
28838 {
28839     struct
28840     {
28841         VkCommandBuffer commandBuffer;
28842         uint32_t firstAttachment;
28843         uint32_t attachmentCount;
28844         const VkColorBlendAdvancedEXT *pColorBlendAdvanced;
28845     } *params = args;
28846
28847     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendAdvanced);
28848
28849     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendAdvancedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendAdvanced);
28850     return STATUS_SUCCESS;
28851 }
28852
28853 #endif /* USE_STRUCT_CONVERSION */
28854
28855 #if !defined(USE_STRUCT_CONVERSION)
28856
28857 static NTSTATUS thunk64_vkCmdSetColorBlendEnableEXT(void *args)
28858 {
28859     struct vkCmdSetColorBlendEnableEXT_params *params = args;
28860
28861     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEnables);
28862
28863     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEnables);
28864     return STATUS_SUCCESS;
28865 }
28866
28867 #else /* USE_STRUCT_CONVERSION */
28868
28869 static NTSTATUS thunk32_vkCmdSetColorBlendEnableEXT(void *args)
28870 {
28871     struct
28872     {
28873         VkCommandBuffer commandBuffer;
28874         uint32_t firstAttachment;
28875         uint32_t attachmentCount;
28876         const VkBool32 *pColorBlendEnables;
28877     } *params = args;
28878
28879     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEnables);
28880
28881     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEnables);
28882     return STATUS_SUCCESS;
28883 }
28884
28885 #endif /* USE_STRUCT_CONVERSION */
28886
28887 #if !defined(USE_STRUCT_CONVERSION)
28888
28889 static NTSTATUS thunk64_vkCmdSetColorBlendEquationEXT(void *args)
28890 {
28891     struct vkCmdSetColorBlendEquationEXT_params *params = args;
28892
28893     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEquations);
28894
28895     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendEquationEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEquations);
28896     return STATUS_SUCCESS;
28897 }
28898
28899 #else /* USE_STRUCT_CONVERSION */
28900
28901 static NTSTATUS thunk32_vkCmdSetColorBlendEquationEXT(void *args)
28902 {
28903     struct
28904     {
28905         VkCommandBuffer commandBuffer;
28906         uint32_t firstAttachment;
28907         uint32_t attachmentCount;
28908         const VkColorBlendEquationEXT *pColorBlendEquations;
28909     } *params = args;
28910
28911     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEquations);
28912
28913     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendEquationEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEquations);
28914     return STATUS_SUCCESS;
28915 }
28916
28917 #endif /* USE_STRUCT_CONVERSION */
28918
28919 #if !defined(USE_STRUCT_CONVERSION)
28920
28921 static NTSTATUS thunk64_vkCmdSetColorWriteEnableEXT(void *args)
28922 {
28923     struct vkCmdSetColorWriteEnableEXT_params *params = args;
28924
28925     TRACE("%p, %u, %p\n", params->commandBuffer, params->attachmentCount, params->pColorWriteEnables);
28926
28927     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pColorWriteEnables);
28928     return STATUS_SUCCESS;
28929 }
28930
28931 #else /* USE_STRUCT_CONVERSION */
28932
28933 static NTSTATUS thunk32_vkCmdSetColorWriteEnableEXT(void *args)
28934 {
28935     struct
28936     {
28937         VkCommandBuffer commandBuffer;
28938         uint32_t attachmentCount;
28939         const VkBool32 *pColorWriteEnables;
28940     } *params = args;
28941
28942     TRACE("%p, %u, %p\n", params->commandBuffer, params->attachmentCount, params->pColorWriteEnables);
28943
28944     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pColorWriteEnables);
28945     return STATUS_SUCCESS;
28946 }
28947
28948 #endif /* USE_STRUCT_CONVERSION */
28949
28950 #if !defined(USE_STRUCT_CONVERSION)
28951
28952 static NTSTATUS thunk64_vkCmdSetColorWriteMaskEXT(void *args)
28953 {
28954     struct vkCmdSetColorWriteMaskEXT_params *params = args;
28955
28956     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorWriteMasks);
28957
28958     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorWriteMasks);
28959     return STATUS_SUCCESS;
28960 }
28961
28962 #else /* USE_STRUCT_CONVERSION */
28963
28964 static NTSTATUS thunk32_vkCmdSetColorWriteMaskEXT(void *args)
28965 {
28966     struct
28967     {
28968         VkCommandBuffer commandBuffer;
28969         uint32_t firstAttachment;
28970         uint32_t attachmentCount;
28971         const VkColorComponentFlags *pColorWriteMasks;
28972     } *params = args;
28973
28974     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorWriteMasks);
28975
28976     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorWriteMasks);
28977     return STATUS_SUCCESS;
28978 }
28979
28980 #endif /* USE_STRUCT_CONVERSION */
28981
28982 #if !defined(USE_STRUCT_CONVERSION)
28983
28984 static NTSTATUS thunk64_vkCmdSetConservativeRasterizationModeEXT(void *args)
28985 {
28986     struct vkCmdSetConservativeRasterizationModeEXT_params *params = args;
28987
28988     TRACE("%p, %#x\n", params->commandBuffer, params->conservativeRasterizationMode);
28989
28990     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetConservativeRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->conservativeRasterizationMode);
28991     return STATUS_SUCCESS;
28992 }
28993
28994 #else /* USE_STRUCT_CONVERSION */
28995
28996 static NTSTATUS thunk32_vkCmdSetConservativeRasterizationModeEXT(void *args)
28997 {
28998     struct
28999     {
29000         VkCommandBuffer commandBuffer;
29001         VkConservativeRasterizationModeEXT conservativeRasterizationMode;
29002     } *params = args;
29003
29004     TRACE("%p, %#x\n", params->commandBuffer, params->conservativeRasterizationMode);
29005
29006     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetConservativeRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->conservativeRasterizationMode);
29007     return STATUS_SUCCESS;
29008 }
29009
29010 #endif /* USE_STRUCT_CONVERSION */
29011
29012 #if !defined(USE_STRUCT_CONVERSION)
29013
29014 static NTSTATUS thunk64_vkCmdSetCoverageModulationModeNV(void *args)
29015 {
29016     struct vkCmdSetCoverageModulationModeNV_params *params = args;
29017
29018     TRACE("%p, %#x\n", params->commandBuffer, params->coverageModulationMode);
29019
29020     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationMode);
29021     return STATUS_SUCCESS;
29022 }
29023
29024 #else /* USE_STRUCT_CONVERSION */
29025
29026 static NTSTATUS thunk32_vkCmdSetCoverageModulationModeNV(void *args)
29027 {
29028     struct
29029     {
29030         VkCommandBuffer commandBuffer;
29031         VkCoverageModulationModeNV coverageModulationMode;
29032     } *params = args;
29033
29034     TRACE("%p, %#x\n", params->commandBuffer, params->coverageModulationMode);
29035
29036     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationMode);
29037     return STATUS_SUCCESS;
29038 }
29039
29040 #endif /* USE_STRUCT_CONVERSION */
29041
29042 #if !defined(USE_STRUCT_CONVERSION)
29043
29044 static NTSTATUS thunk64_vkCmdSetCoverageModulationTableEnableNV(void *args)
29045 {
29046     struct vkCmdSetCoverageModulationTableEnableNV_params *params = args;
29047
29048     TRACE("%p, %u\n", params->commandBuffer, params->coverageModulationTableEnable);
29049
29050     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableEnable);
29051     return STATUS_SUCCESS;
29052 }
29053
29054 #else /* USE_STRUCT_CONVERSION */
29055
29056 static NTSTATUS thunk32_vkCmdSetCoverageModulationTableEnableNV(void *args)
29057 {
29058     struct
29059     {
29060         VkCommandBuffer commandBuffer;
29061         VkBool32 coverageModulationTableEnable;
29062     } *params = args;
29063
29064     TRACE("%p, %u\n", params->commandBuffer, params->coverageModulationTableEnable);
29065
29066     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableEnable);
29067     return STATUS_SUCCESS;
29068 }
29069
29070 #endif /* USE_STRUCT_CONVERSION */
29071
29072 #if !defined(USE_STRUCT_CONVERSION)
29073
29074 static NTSTATUS thunk64_vkCmdSetCoverageModulationTableNV(void *args)
29075 {
29076     struct vkCmdSetCoverageModulationTableNV_params *params = args;
29077
29078     TRACE("%p, %u, %p\n", params->commandBuffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
29079
29080     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
29081     return STATUS_SUCCESS;
29082 }
29083
29084 #else /* USE_STRUCT_CONVERSION */
29085
29086 static NTSTATUS thunk32_vkCmdSetCoverageModulationTableNV(void *args)
29087 {
29088     struct
29089     {
29090         VkCommandBuffer commandBuffer;
29091         uint32_t coverageModulationTableCount;
29092         const float *pCoverageModulationTable;
29093     } *params = args;
29094
29095     TRACE("%p, %u, %p\n", params->commandBuffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
29096
29097     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
29098     return STATUS_SUCCESS;
29099 }
29100
29101 #endif /* USE_STRUCT_CONVERSION */
29102
29103 #if !defined(USE_STRUCT_CONVERSION)
29104
29105 static NTSTATUS thunk64_vkCmdSetCoverageReductionModeNV(void *args)
29106 {
29107     struct vkCmdSetCoverageReductionModeNV_params *params = args;
29108
29109     TRACE("%p, %#x\n", params->commandBuffer, params->coverageReductionMode);
29110
29111     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageReductionModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageReductionMode);
29112     return STATUS_SUCCESS;
29113 }
29114
29115 #else /* USE_STRUCT_CONVERSION */
29116
29117 static NTSTATUS thunk32_vkCmdSetCoverageReductionModeNV(void *args)
29118 {
29119     struct
29120     {
29121         VkCommandBuffer commandBuffer;
29122         VkCoverageReductionModeNV coverageReductionMode;
29123     } *params = args;
29124
29125     TRACE("%p, %#x\n", params->commandBuffer, params->coverageReductionMode);
29126
29127     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageReductionModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageReductionMode);
29128     return STATUS_SUCCESS;
29129 }
29130
29131 #endif /* USE_STRUCT_CONVERSION */
29132
29133 #if !defined(USE_STRUCT_CONVERSION)
29134
29135 static NTSTATUS thunk64_vkCmdSetCoverageToColorEnableNV(void *args)
29136 {
29137     struct vkCmdSetCoverageToColorEnableNV_params *params = args;
29138
29139     TRACE("%p, %u\n", params->commandBuffer, params->coverageToColorEnable);
29140
29141     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorEnable);
29142     return STATUS_SUCCESS;
29143 }
29144
29145 #else /* USE_STRUCT_CONVERSION */
29146
29147 static NTSTATUS thunk32_vkCmdSetCoverageToColorEnableNV(void *args)
29148 {
29149     struct
29150     {
29151         VkCommandBuffer commandBuffer;
29152         VkBool32 coverageToColorEnable;
29153     } *params = args;
29154
29155     TRACE("%p, %u\n", params->commandBuffer, params->coverageToColorEnable);
29156
29157     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorEnable);
29158     return STATUS_SUCCESS;
29159 }
29160
29161 #endif /* USE_STRUCT_CONVERSION */
29162
29163 #if !defined(USE_STRUCT_CONVERSION)
29164
29165 static NTSTATUS thunk64_vkCmdSetCoverageToColorLocationNV(void *args)
29166 {
29167     struct vkCmdSetCoverageToColorLocationNV_params *params = args;
29168
29169     TRACE("%p, %u\n", params->commandBuffer, params->coverageToColorLocation);
29170
29171     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorLocationNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorLocation);
29172     return STATUS_SUCCESS;
29173 }
29174
29175 #else /* USE_STRUCT_CONVERSION */
29176
29177 static NTSTATUS thunk32_vkCmdSetCoverageToColorLocationNV(void *args)
29178 {
29179     struct
29180     {
29181         VkCommandBuffer commandBuffer;
29182         uint32_t coverageToColorLocation;
29183     } *params = args;
29184
29185     TRACE("%p, %u\n", params->commandBuffer, params->coverageToColorLocation);
29186
29187     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorLocationNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorLocation);
29188     return STATUS_SUCCESS;
29189 }
29190
29191 #endif /* USE_STRUCT_CONVERSION */
29192
29193 #if !defined(USE_STRUCT_CONVERSION)
29194
29195 static NTSTATUS thunk64_vkCmdSetCullMode(void *args)
29196 {
29197     struct vkCmdSetCullMode_params *params = args;
29198
29199     TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
29200
29201     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullMode(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
29202     return STATUS_SUCCESS;
29203 }
29204
29205 #else /* USE_STRUCT_CONVERSION */
29206
29207 static NTSTATUS thunk32_vkCmdSetCullMode(void *args)
29208 {
29209     struct
29210     {
29211         VkCommandBuffer commandBuffer;
29212         VkCullModeFlags cullMode;
29213     } *params = args;
29214
29215     TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
29216
29217     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullMode(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
29218     return STATUS_SUCCESS;
29219 }
29220
29221 #endif /* USE_STRUCT_CONVERSION */
29222
29223 #if !defined(USE_STRUCT_CONVERSION)
29224
29225 static NTSTATUS thunk64_vkCmdSetCullModeEXT(void *args)
29226 {
29227     struct vkCmdSetCullModeEXT_params *params = args;
29228
29229     TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
29230
29231     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
29232     return STATUS_SUCCESS;
29233 }
29234
29235 #else /* USE_STRUCT_CONVERSION */
29236
29237 static NTSTATUS thunk32_vkCmdSetCullModeEXT(void *args)
29238 {
29239     struct
29240     {
29241         VkCommandBuffer commandBuffer;
29242         VkCullModeFlags cullMode;
29243     } *params = args;
29244
29245     TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
29246
29247     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
29248     return STATUS_SUCCESS;
29249 }
29250
29251 #endif /* USE_STRUCT_CONVERSION */
29252
29253 #if !defined(USE_STRUCT_CONVERSION)
29254
29255 static NTSTATUS thunk64_vkCmdSetDepthBias(void *args)
29256 {
29257     struct vkCmdSetDepthBias_params *params = args;
29258
29259     TRACE("%p, %f, %f, %f\n", params->commandBuffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
29260
29261     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBias(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
29262     return STATUS_SUCCESS;
29263 }
29264
29265 #else /* USE_STRUCT_CONVERSION */
29266
29267 static NTSTATUS thunk32_vkCmdSetDepthBias(void *args)
29268 {
29269     struct
29270     {
29271         VkCommandBuffer commandBuffer;
29272         float depthBiasConstantFactor;
29273         float depthBiasClamp;
29274         float depthBiasSlopeFactor;
29275     } *params = args;
29276
29277     TRACE("%p, %f, %f, %f\n", params->commandBuffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
29278
29279     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBias(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
29280     return STATUS_SUCCESS;
29281 }
29282
29283 #endif /* USE_STRUCT_CONVERSION */
29284
29285 #if !defined(USE_STRUCT_CONVERSION)
29286
29287 static NTSTATUS thunk64_vkCmdSetDepthBiasEnable(void *args)
29288 {
29289     struct vkCmdSetDepthBiasEnable_params *params = args;
29290
29291     TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
29292
29293     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
29294     return STATUS_SUCCESS;
29295 }
29296
29297 #else /* USE_STRUCT_CONVERSION */
29298
29299 static NTSTATUS thunk32_vkCmdSetDepthBiasEnable(void *args)
29300 {
29301     struct
29302     {
29303         VkCommandBuffer commandBuffer;
29304         VkBool32 depthBiasEnable;
29305     } *params = args;
29306
29307     TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
29308
29309     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
29310     return STATUS_SUCCESS;
29311 }
29312
29313 #endif /* USE_STRUCT_CONVERSION */
29314
29315 #if !defined(USE_STRUCT_CONVERSION)
29316
29317 static NTSTATUS thunk64_vkCmdSetDepthBiasEnableEXT(void *args)
29318 {
29319     struct vkCmdSetDepthBiasEnableEXT_params *params = args;
29320
29321     TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
29322
29323     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
29324     return STATUS_SUCCESS;
29325 }
29326
29327 #else /* USE_STRUCT_CONVERSION */
29328
29329 static NTSTATUS thunk32_vkCmdSetDepthBiasEnableEXT(void *args)
29330 {
29331     struct
29332     {
29333         VkCommandBuffer commandBuffer;
29334         VkBool32 depthBiasEnable;
29335     } *params = args;
29336
29337     TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
29338
29339     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
29340     return STATUS_SUCCESS;
29341 }
29342
29343 #endif /* USE_STRUCT_CONVERSION */
29344
29345 #if !defined(USE_STRUCT_CONVERSION)
29346
29347 static NTSTATUS thunk64_vkCmdSetDepthBounds(void *args)
29348 {
29349     struct vkCmdSetDepthBounds_params *params = args;
29350
29351     TRACE("%p, %f, %f\n", params->commandBuffer, params->minDepthBounds, params->maxDepthBounds);
29352
29353     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBounds(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->minDepthBounds, params->maxDepthBounds);
29354     return STATUS_SUCCESS;
29355 }
29356
29357 #else /* USE_STRUCT_CONVERSION */
29358
29359 static NTSTATUS thunk32_vkCmdSetDepthBounds(void *args)
29360 {
29361     struct
29362     {
29363         VkCommandBuffer commandBuffer;
29364         float minDepthBounds;
29365         float maxDepthBounds;
29366     } *params = args;
29367
29368     TRACE("%p, %f, %f\n", params->commandBuffer, params->minDepthBounds, params->maxDepthBounds);
29369
29370     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBounds(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->minDepthBounds, params->maxDepthBounds);
29371     return STATUS_SUCCESS;
29372 }
29373
29374 #endif /* USE_STRUCT_CONVERSION */
29375
29376 #if !defined(USE_STRUCT_CONVERSION)
29377
29378 static NTSTATUS thunk64_vkCmdSetDepthBoundsTestEnable(void *args)
29379 {
29380     struct vkCmdSetDepthBoundsTestEnable_params *params = args;
29381
29382     TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
29383
29384     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
29385     return STATUS_SUCCESS;
29386 }
29387
29388 #else /* USE_STRUCT_CONVERSION */
29389
29390 static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnable(void *args)
29391 {
29392     struct
29393     {
29394         VkCommandBuffer commandBuffer;
29395         VkBool32 depthBoundsTestEnable;
29396     } *params = args;
29397
29398     TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
29399
29400     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
29401     return STATUS_SUCCESS;
29402 }
29403
29404 #endif /* USE_STRUCT_CONVERSION */
29405
29406 #if !defined(USE_STRUCT_CONVERSION)
29407
29408 static NTSTATUS thunk64_vkCmdSetDepthBoundsTestEnableEXT(void *args)
29409 {
29410     struct vkCmdSetDepthBoundsTestEnableEXT_params *params = args;
29411
29412     TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
29413
29414     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
29415     return STATUS_SUCCESS;
29416 }
29417
29418 #else /* USE_STRUCT_CONVERSION */
29419
29420 static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnableEXT(void *args)
29421 {
29422     struct
29423     {
29424         VkCommandBuffer commandBuffer;
29425         VkBool32 depthBoundsTestEnable;
29426     } *params = args;
29427
29428     TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
29429
29430     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
29431     return STATUS_SUCCESS;
29432 }
29433
29434 #endif /* USE_STRUCT_CONVERSION */
29435
29436 #if !defined(USE_STRUCT_CONVERSION)
29437
29438 static NTSTATUS thunk64_vkCmdSetDepthClampEnableEXT(void *args)
29439 {
29440     struct vkCmdSetDepthClampEnableEXT_params *params = args;
29441
29442     TRACE("%p, %u\n", params->commandBuffer, params->depthClampEnable);
29443
29444     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClampEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClampEnable);
29445     return STATUS_SUCCESS;
29446 }
29447
29448 #else /* USE_STRUCT_CONVERSION */
29449
29450 static NTSTATUS thunk32_vkCmdSetDepthClampEnableEXT(void *args)
29451 {
29452     struct
29453     {
29454         VkCommandBuffer commandBuffer;
29455         VkBool32 depthClampEnable;
29456     } *params = args;
29457
29458     TRACE("%p, %u\n", params->commandBuffer, params->depthClampEnable);
29459
29460     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClampEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClampEnable);
29461     return STATUS_SUCCESS;
29462 }
29463
29464 #endif /* USE_STRUCT_CONVERSION */
29465
29466 #if !defined(USE_STRUCT_CONVERSION)
29467
29468 static NTSTATUS thunk64_vkCmdSetDepthClipEnableEXT(void *args)
29469 {
29470     struct vkCmdSetDepthClipEnableEXT_params *params = args;
29471
29472     TRACE("%p, %u\n", params->commandBuffer, params->depthClipEnable);
29473
29474     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClipEnable);
29475     return STATUS_SUCCESS;
29476 }
29477
29478 #else /* USE_STRUCT_CONVERSION */
29479
29480 static NTSTATUS thunk32_vkCmdSetDepthClipEnableEXT(void *args)
29481 {
29482     struct
29483     {
29484         VkCommandBuffer commandBuffer;
29485         VkBool32 depthClipEnable;
29486     } *params = args;
29487
29488     TRACE("%p, %u\n", params->commandBuffer, params->depthClipEnable);
29489
29490     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClipEnable);
29491     return STATUS_SUCCESS;
29492 }
29493
29494 #endif /* USE_STRUCT_CONVERSION */
29495
29496 #if !defined(USE_STRUCT_CONVERSION)
29497
29498 static NTSTATUS thunk64_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
29499 {
29500     struct vkCmdSetDepthClipNegativeOneToOneEXT_params *params = args;
29501
29502     TRACE("%p, %u\n", params->commandBuffer, params->negativeOneToOne);
29503
29504     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipNegativeOneToOneEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->negativeOneToOne);
29505     return STATUS_SUCCESS;
29506 }
29507
29508 #else /* USE_STRUCT_CONVERSION */
29509
29510 static NTSTATUS thunk32_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
29511 {
29512     struct
29513     {
29514         VkCommandBuffer commandBuffer;
29515         VkBool32 negativeOneToOne;
29516     } *params = args;
29517
29518     TRACE("%p, %u\n", params->commandBuffer, params->negativeOneToOne);
29519
29520     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipNegativeOneToOneEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->negativeOneToOne);
29521     return STATUS_SUCCESS;
29522 }
29523
29524 #endif /* USE_STRUCT_CONVERSION */
29525
29526 #if !defined(USE_STRUCT_CONVERSION)
29527
29528 static NTSTATUS thunk64_vkCmdSetDepthCompareOp(void *args)
29529 {
29530     struct vkCmdSetDepthCompareOp_params *params = args;
29531
29532     TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
29533
29534     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
29535     return STATUS_SUCCESS;
29536 }
29537
29538 #else /* USE_STRUCT_CONVERSION */
29539
29540 static NTSTATUS thunk32_vkCmdSetDepthCompareOp(void *args)
29541 {
29542     struct
29543     {
29544         VkCommandBuffer commandBuffer;
29545         VkCompareOp depthCompareOp;
29546     } *params = args;
29547
29548     TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
29549
29550     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
29551     return STATUS_SUCCESS;
29552 }
29553
29554 #endif /* USE_STRUCT_CONVERSION */
29555
29556 #if !defined(USE_STRUCT_CONVERSION)
29557
29558 static NTSTATUS thunk64_vkCmdSetDepthCompareOpEXT(void *args)
29559 {
29560     struct vkCmdSetDepthCompareOpEXT_params *params = args;
29561
29562     TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
29563
29564     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
29565     return STATUS_SUCCESS;
29566 }
29567
29568 #else /* USE_STRUCT_CONVERSION */
29569
29570 static NTSTATUS thunk32_vkCmdSetDepthCompareOpEXT(void *args)
29571 {
29572     struct
29573     {
29574         VkCommandBuffer commandBuffer;
29575         VkCompareOp depthCompareOp;
29576     } *params = args;
29577
29578     TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
29579
29580     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
29581     return STATUS_SUCCESS;
29582 }
29583
29584 #endif /* USE_STRUCT_CONVERSION */
29585
29586 #if !defined(USE_STRUCT_CONVERSION)
29587
29588 static NTSTATUS thunk64_vkCmdSetDepthTestEnable(void *args)
29589 {
29590     struct vkCmdSetDepthTestEnable_params *params = args;
29591
29592     TRACE("%p, %u\n", params->commandBuffer, params->depthTestEnable);
29593
29594     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
29595     return STATUS_SUCCESS;
29596 }
29597
29598 #else /* USE_STRUCT_CONVERSION */
29599
29600 static NTSTATUS thunk32_vkCmdSetDepthTestEnable(void *args)
29601 {
29602     struct
29603     {
29604         VkCommandBuffer commandBuffer;
29605         VkBool32 depthTestEnable;
29606     } *params = args;
29607
29608     TRACE("%p, %u\n", params->commandBuffer, params->depthTestEnable);
29609
29610     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
29611     return STATUS_SUCCESS;
29612 }
29613
29614 #endif /* USE_STRUCT_CONVERSION */
29615
29616 #if !defined(USE_STRUCT_CONVERSION)
29617
29618 static NTSTATUS thunk64_vkCmdSetDepthTestEnableEXT(void *args)
29619 {
29620     struct vkCmdSetDepthTestEnableEXT_params *params = args;
29621
29622     TRACE("%p, %u\n", params->commandBuffer, params->depthTestEnable);
29623
29624     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
29625     return STATUS_SUCCESS;
29626 }
29627
29628 #else /* USE_STRUCT_CONVERSION */
29629
29630 static NTSTATUS thunk32_vkCmdSetDepthTestEnableEXT(void *args)
29631 {
29632     struct
29633     {
29634         VkCommandBuffer commandBuffer;
29635         VkBool32 depthTestEnable;
29636     } *params = args;
29637
29638     TRACE("%p, %u\n", params->commandBuffer, params->depthTestEnable);
29639
29640     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
29641     return STATUS_SUCCESS;
29642 }
29643
29644 #endif /* USE_STRUCT_CONVERSION */
29645
29646 #if !defined(USE_STRUCT_CONVERSION)
29647
29648 static NTSTATUS thunk64_vkCmdSetDepthWriteEnable(void *args)
29649 {
29650     struct vkCmdSetDepthWriteEnable_params *params = args;
29651
29652     TRACE("%p, %u\n", params->commandBuffer, params->depthWriteEnable);
29653
29654     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
29655     return STATUS_SUCCESS;
29656 }
29657
29658 #else /* USE_STRUCT_CONVERSION */
29659
29660 static NTSTATUS thunk32_vkCmdSetDepthWriteEnable(void *args)
29661 {
29662     struct
29663     {
29664         VkCommandBuffer commandBuffer;
29665         VkBool32 depthWriteEnable;
29666     } *params = args;
29667
29668     TRACE("%p, %u\n", params->commandBuffer, params->depthWriteEnable);
29669
29670     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
29671     return STATUS_SUCCESS;
29672 }
29673
29674 #endif /* USE_STRUCT_CONVERSION */
29675
29676 #if !defined(USE_STRUCT_CONVERSION)
29677
29678 static NTSTATUS thunk64_vkCmdSetDepthWriteEnableEXT(void *args)
29679 {
29680     struct vkCmdSetDepthWriteEnableEXT_params *params = args;
29681
29682     TRACE("%p, %u\n", params->commandBuffer, params->depthWriteEnable);
29683
29684     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
29685     return STATUS_SUCCESS;
29686 }
29687
29688 #else /* USE_STRUCT_CONVERSION */
29689
29690 static NTSTATUS thunk32_vkCmdSetDepthWriteEnableEXT(void *args)
29691 {
29692     struct
29693     {
29694         VkCommandBuffer commandBuffer;
29695         VkBool32 depthWriteEnable;
29696     } *params = args;
29697
29698     TRACE("%p, %u\n", params->commandBuffer, params->depthWriteEnable);
29699
29700     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
29701     return STATUS_SUCCESS;
29702 }
29703
29704 #endif /* USE_STRUCT_CONVERSION */
29705
29706 #if !defined(USE_STRUCT_CONVERSION)
29707
29708 static NTSTATUS thunk64_vkCmdSetDeviceMask(void *args)
29709 {
29710     struct vkCmdSetDeviceMask_params *params = args;
29711
29712     TRACE("%p, %u\n", params->commandBuffer, params->deviceMask);
29713
29714     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
29715     return STATUS_SUCCESS;
29716 }
29717
29718 #else /* USE_STRUCT_CONVERSION */
29719
29720 static NTSTATUS thunk32_vkCmdSetDeviceMask(void *args)
29721 {
29722     struct
29723     {
29724         VkCommandBuffer commandBuffer;
29725         uint32_t deviceMask;
29726     } *params = args;
29727
29728     TRACE("%p, %u\n", params->commandBuffer, params->deviceMask);
29729
29730     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
29731     return STATUS_SUCCESS;
29732 }
29733
29734 #endif /* USE_STRUCT_CONVERSION */
29735
29736 #if !defined(USE_STRUCT_CONVERSION)
29737
29738 static NTSTATUS thunk64_vkCmdSetDeviceMaskKHR(void *args)
29739 {
29740     struct vkCmdSetDeviceMaskKHR_params *params = args;
29741
29742     TRACE("%p, %u\n", params->commandBuffer, params->deviceMask);
29743
29744     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMaskKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
29745     return STATUS_SUCCESS;
29746 }
29747
29748 #else /* USE_STRUCT_CONVERSION */
29749
29750 static NTSTATUS thunk32_vkCmdSetDeviceMaskKHR(void *args)
29751 {
29752     struct
29753     {
29754         VkCommandBuffer commandBuffer;
29755         uint32_t deviceMask;
29756     } *params = args;
29757
29758     TRACE("%p, %u\n", params->commandBuffer, params->deviceMask);
29759
29760     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMaskKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
29761     return STATUS_SUCCESS;
29762 }
29763
29764 #endif /* USE_STRUCT_CONVERSION */
29765
29766 #if !defined(USE_STRUCT_CONVERSION)
29767
29768 static NTSTATUS thunk64_vkCmdSetDiscardRectangleEXT(void *args)
29769 {
29770     struct vkCmdSetDiscardRectangleEXT_params *params = args;
29771
29772     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstDiscardRectangle, params->discardRectangleCount, params->pDiscardRectangles);
29773
29774     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDiscardRectangleEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstDiscardRectangle, params->discardRectangleCount, params->pDiscardRectangles);
29775     return STATUS_SUCCESS;
29776 }
29777
29778 #else /* USE_STRUCT_CONVERSION */
29779
29780 static NTSTATUS thunk32_vkCmdSetDiscardRectangleEXT(void *args)
29781 {
29782     struct
29783     {
29784         VkCommandBuffer commandBuffer;
29785         uint32_t firstDiscardRectangle;
29786         uint32_t discardRectangleCount;
29787         const VkRect2D *pDiscardRectangles;
29788     } *params = args;
29789
29790     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstDiscardRectangle, params->discardRectangleCount, params->pDiscardRectangles);
29791
29792     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDiscardRectangleEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstDiscardRectangle, params->discardRectangleCount, params->pDiscardRectangles);
29793     return STATUS_SUCCESS;
29794 }
29795
29796 #endif /* USE_STRUCT_CONVERSION */
29797
29798 #if !defined(USE_STRUCT_CONVERSION)
29799
29800 static NTSTATUS thunk64_vkCmdSetEvent(void *args)
29801 {
29802     struct vkCmdSetEvent_params *params = args;
29803
29804     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);
29805
29806     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
29807     return STATUS_SUCCESS;
29808 }
29809
29810 #else /* USE_STRUCT_CONVERSION */
29811
29812 static NTSTATUS thunk32_vkCmdSetEvent(void *args)
29813 {
29814     struct
29815     {
29816         VkCommandBuffer commandBuffer;
29817         VkEvent DECLSPEC_ALIGN(8) event;
29818         VkPipelineStageFlags stageMask;
29819     } *params = args;
29820
29821     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);
29822
29823     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
29824     return STATUS_SUCCESS;
29825 }
29826
29827 #endif /* USE_STRUCT_CONVERSION */
29828
29829 #if !defined(USE_STRUCT_CONVERSION)
29830
29831 static NTSTATUS thunk64_vkCmdSetEvent2(void *args)
29832 {
29833     struct vkCmdSetEvent2_params *params = args;
29834
29835     TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);
29836
29837     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->pDependencyInfo);
29838     return STATUS_SUCCESS;
29839 }
29840
29841 #else /* USE_STRUCT_CONVERSION */
29842
29843 static NTSTATUS thunk32_vkCmdSetEvent2(void *args)
29844 {
29845     struct
29846     {
29847         VkCommandBuffer commandBuffer;
29848         VkEvent DECLSPEC_ALIGN(8) event;
29849         const VkDependencyInfo32 *pDependencyInfo;
29850     } *params = args;
29851     VkDependencyInfo pDependencyInfo_host;
29852     struct conversion_context ctx;
29853
29854     TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);
29855
29856     init_conversion_context(&ctx);
29857     convert_VkDependencyInfo_win32_to_host(&ctx, params->pDependencyInfo, &pDependencyInfo_host);
29858     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, &pDependencyInfo_host);
29859     free_conversion_context(&ctx);
29860     return STATUS_SUCCESS;
29861 }
29862
29863 #endif /* USE_STRUCT_CONVERSION */
29864
29865 #if !defined(USE_STRUCT_CONVERSION)
29866
29867 static NTSTATUS thunk64_vkCmdSetEvent2KHR(void *args)
29868 {
29869     struct vkCmdSetEvent2KHR_params *params = args;
29870
29871     TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);
29872
29873     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->pDependencyInfo);
29874     return STATUS_SUCCESS;
29875 }
29876
29877 #else /* USE_STRUCT_CONVERSION */
29878
29879 static NTSTATUS thunk32_vkCmdSetEvent2KHR(void *args)
29880 {
29881     struct
29882     {
29883         VkCommandBuffer commandBuffer;
29884         VkEvent DECLSPEC_ALIGN(8) event;
29885         const VkDependencyInfo32 *pDependencyInfo;
29886     } *params = args;
29887     VkDependencyInfo pDependencyInfo_host;
29888     struct conversion_context ctx;
29889
29890     TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);
29891
29892     init_conversion_context(&ctx);
29893     convert_VkDependencyInfo_win32_to_host(&ctx, params->pDependencyInfo, &pDependencyInfo_host);
29894     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, &pDependencyInfo_host);
29895     free_conversion_context(&ctx);
29896     return STATUS_SUCCESS;
29897 }
29898
29899 #endif /* USE_STRUCT_CONVERSION */
29900
29901 #if !defined(USE_STRUCT_CONVERSION)
29902
29903 static NTSTATUS thunk64_vkCmdSetExclusiveScissorNV(void *args)
29904 {
29905     struct vkCmdSetExclusiveScissorNV_params *params = args;
29906
29907     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstExclusiveScissor, params->exclusiveScissorCount, params->pExclusiveScissors);
29908
29909     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetExclusiveScissorNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstExclusiveScissor, params->exclusiveScissorCount, params->pExclusiveScissors);
29910     return STATUS_SUCCESS;
29911 }
29912
29913 #else /* USE_STRUCT_CONVERSION */
29914
29915 static NTSTATUS thunk32_vkCmdSetExclusiveScissorNV(void *args)
29916 {
29917     struct
29918     {
29919         VkCommandBuffer commandBuffer;
29920         uint32_t firstExclusiveScissor;
29921         uint32_t exclusiveScissorCount;
29922         const VkRect2D *pExclusiveScissors;
29923     } *params = args;
29924
29925     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstExclusiveScissor, params->exclusiveScissorCount, params->pExclusiveScissors);
29926
29927     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetExclusiveScissorNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstExclusiveScissor, params->exclusiveScissorCount, params->pExclusiveScissors);
29928     return STATUS_SUCCESS;
29929 }
29930
29931 #endif /* USE_STRUCT_CONVERSION */
29932
29933 #if !defined(USE_STRUCT_CONVERSION)
29934
29935 static NTSTATUS thunk64_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
29936 {
29937     struct vkCmdSetExtraPrimitiveOverestimationSizeEXT_params *params = args;
29938
29939     TRACE("%p, %f\n", params->commandBuffer, params->extraPrimitiveOverestimationSize);
29940
29941     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetExtraPrimitiveOverestimationSizeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->extraPrimitiveOverestimationSize);
29942     return STATUS_SUCCESS;
29943 }
29944
29945 #else /* USE_STRUCT_CONVERSION */
29946
29947 static NTSTATUS thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
29948 {
29949     struct
29950     {
29951         VkCommandBuffer commandBuffer;
29952         float extraPrimitiveOverestimationSize;
29953     } *params = args;
29954
29955     TRACE("%p, %f\n", params->commandBuffer, params->extraPrimitiveOverestimationSize);
29956
29957     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetExtraPrimitiveOverestimationSizeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->extraPrimitiveOverestimationSize);
29958     return STATUS_SUCCESS;
29959 }
29960
29961 #endif /* USE_STRUCT_CONVERSION */
29962
29963 #if !defined(USE_STRUCT_CONVERSION)
29964
29965 static NTSTATUS thunk64_vkCmdSetFragmentShadingRateEnumNV(void *args)
29966 {
29967     struct vkCmdSetFragmentShadingRateEnumNV_params *params = args;
29968
29969     TRACE("%p, %#x, %p\n", params->commandBuffer, params->shadingRate, params->combinerOps);
29970
29971     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateEnumNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRate, params->combinerOps);
29972     return STATUS_SUCCESS;
29973 }
29974
29975 #else /* USE_STRUCT_CONVERSION */
29976
29977 static NTSTATUS thunk32_vkCmdSetFragmentShadingRateEnumNV(void *args)
29978 {
29979     struct
29980     {
29981         VkCommandBuffer commandBuffer;
29982         VkFragmentShadingRateNV shadingRate;
29983         const VkFragmentShadingRateCombinerOpKHR *combinerOps;
29984     } *params = args;
29985
29986     TRACE("%p, %#x, %p\n", params->commandBuffer, params->shadingRate, params->combinerOps);
29987
29988     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateEnumNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRate, params->combinerOps);
29989     return STATUS_SUCCESS;
29990 }
29991
29992 #endif /* USE_STRUCT_CONVERSION */
29993
29994 #if !defined(USE_STRUCT_CONVERSION)
29995
29996 static NTSTATUS thunk64_vkCmdSetFragmentShadingRateKHR(void *args)
29997 {
29998     struct vkCmdSetFragmentShadingRateKHR_params *params = args;
29999
30000     TRACE("%p, %p, %p\n", params->commandBuffer, params->pFragmentSize, params->combinerOps);
30001
30002     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pFragmentSize, params->combinerOps);
30003     return STATUS_SUCCESS;
30004 }
30005
30006 #else /* USE_STRUCT_CONVERSION */
30007
30008 static NTSTATUS thunk32_vkCmdSetFragmentShadingRateKHR(void *args)
30009 {
30010     struct
30011     {
30012         VkCommandBuffer commandBuffer;
30013         const VkExtent2D *pFragmentSize;
30014         const VkFragmentShadingRateCombinerOpKHR *combinerOps;
30015     } *params = args;
30016
30017     TRACE("%p, %p, %p\n", params->commandBuffer, params->pFragmentSize, params->combinerOps);
30018
30019     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pFragmentSize, params->combinerOps);
30020     return STATUS_SUCCESS;
30021 }
30022
30023 #endif /* USE_STRUCT_CONVERSION */
30024
30025 #if !defined(USE_STRUCT_CONVERSION)
30026
30027 static NTSTATUS thunk64_vkCmdSetFrontFace(void *args)
30028 {
30029     struct vkCmdSetFrontFace_params *params = args;
30030
30031     TRACE("%p, %#x\n", params->commandBuffer, params->frontFace);
30032
30033     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFace(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
30034     return STATUS_SUCCESS;
30035 }
30036
30037 #else /* USE_STRUCT_CONVERSION */
30038
30039 static NTSTATUS thunk32_vkCmdSetFrontFace(void *args)
30040 {
30041     struct
30042     {
30043         VkCommandBuffer commandBuffer;
30044         VkFrontFace frontFace;
30045     } *params = args;
30046
30047     TRACE("%p, %#x\n", params->commandBuffer, params->frontFace);
30048
30049     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFace(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
30050     return STATUS_SUCCESS;
30051 }
30052
30053 #endif /* USE_STRUCT_CONVERSION */
30054
30055 #if !defined(USE_STRUCT_CONVERSION)
30056
30057 static NTSTATUS thunk64_vkCmdSetFrontFaceEXT(void *args)
30058 {
30059     struct vkCmdSetFrontFaceEXT_params *params = args;
30060
30061     TRACE("%p, %#x\n", params->commandBuffer, params->frontFace);
30062
30063     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFaceEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
30064     return STATUS_SUCCESS;
30065 }
30066
30067 #else /* USE_STRUCT_CONVERSION */
30068
30069 static NTSTATUS thunk32_vkCmdSetFrontFaceEXT(void *args)
30070 {
30071     struct
30072     {
30073         VkCommandBuffer commandBuffer;
30074         VkFrontFace frontFace;
30075     } *params = args;
30076
30077     TRACE("%p, %#x\n", params->commandBuffer, params->frontFace);
30078
30079     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFaceEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
30080     return STATUS_SUCCESS;
30081 }
30082
30083 #endif /* USE_STRUCT_CONVERSION */
30084
30085 #if !defined(USE_STRUCT_CONVERSION)
30086
30087 static NTSTATUS thunk64_vkCmdSetLineRasterizationModeEXT(void *args)
30088 {
30089     struct vkCmdSetLineRasterizationModeEXT_params *params = args;
30090
30091     TRACE("%p, %#x\n", params->commandBuffer, params->lineRasterizationMode);
30092
30093     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineRasterizationMode);
30094     return STATUS_SUCCESS;
30095 }
30096
30097 #else /* USE_STRUCT_CONVERSION */
30098
30099 static NTSTATUS thunk32_vkCmdSetLineRasterizationModeEXT(void *args)
30100 {
30101     struct
30102     {
30103         VkCommandBuffer commandBuffer;
30104         VkLineRasterizationModeEXT lineRasterizationMode;
30105     } *params = args;
30106
30107     TRACE("%p, %#x\n", params->commandBuffer, params->lineRasterizationMode);
30108
30109     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineRasterizationMode);
30110     return STATUS_SUCCESS;
30111 }
30112
30113 #endif /* USE_STRUCT_CONVERSION */
30114
30115 #if !defined(USE_STRUCT_CONVERSION)
30116
30117 static NTSTATUS thunk64_vkCmdSetLineStippleEXT(void *args)
30118 {
30119     struct vkCmdSetLineStippleEXT_params *params = args;
30120
30121     TRACE("%p, %u, %u\n", params->commandBuffer, params->lineStippleFactor, params->lineStipplePattern);
30122
30123     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineStippleFactor, params->lineStipplePattern);
30124     return STATUS_SUCCESS;
30125 }
30126
30127 #else /* USE_STRUCT_CONVERSION */
30128
30129 static NTSTATUS thunk32_vkCmdSetLineStippleEXT(void *args)
30130 {
30131     struct
30132     {
30133         VkCommandBuffer commandBuffer;
30134         uint32_t lineStippleFactor;
30135         uint16_t lineStipplePattern;
30136     } *params = args;
30137
30138     TRACE("%p, %u, %u\n", params->commandBuffer, params->lineStippleFactor, params->lineStipplePattern);
30139
30140     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineStippleFactor, params->lineStipplePattern);
30141     return STATUS_SUCCESS;
30142 }
30143
30144 #endif /* USE_STRUCT_CONVERSION */
30145
30146 #if !defined(USE_STRUCT_CONVERSION)
30147
30148 static NTSTATUS thunk64_vkCmdSetLineStippleEnableEXT(void *args)
30149 {
30150     struct vkCmdSetLineStippleEnableEXT_params *params = args;
30151
30152     TRACE("%p, %u\n", params->commandBuffer, params->stippledLineEnable);
30153
30154     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stippledLineEnable);
30155     return STATUS_SUCCESS;
30156 }
30157
30158 #else /* USE_STRUCT_CONVERSION */
30159
30160 static NTSTATUS thunk32_vkCmdSetLineStippleEnableEXT(void *args)
30161 {
30162     struct
30163     {
30164         VkCommandBuffer commandBuffer;
30165         VkBool32 stippledLineEnable;
30166     } *params = args;
30167
30168     TRACE("%p, %u\n", params->commandBuffer, params->stippledLineEnable);
30169
30170     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stippledLineEnable);
30171     return STATUS_SUCCESS;
30172 }
30173
30174 #endif /* USE_STRUCT_CONVERSION */
30175
30176 #if !defined(USE_STRUCT_CONVERSION)
30177
30178 static NTSTATUS thunk64_vkCmdSetLineWidth(void *args)
30179 {
30180     struct vkCmdSetLineWidth_params *params = args;
30181
30182     TRACE("%p, %f\n", params->commandBuffer, params->lineWidth);
30183
30184     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineWidth(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineWidth);
30185     return STATUS_SUCCESS;
30186 }
30187
30188 #else /* USE_STRUCT_CONVERSION */
30189
30190 static NTSTATUS thunk32_vkCmdSetLineWidth(void *args)
30191 {
30192     struct
30193     {
30194         VkCommandBuffer commandBuffer;
30195         float lineWidth;
30196     } *params = args;
30197
30198     TRACE("%p, %f\n", params->commandBuffer, params->lineWidth);
30199
30200     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineWidth(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineWidth);
30201     return STATUS_SUCCESS;
30202 }
30203
30204 #endif /* USE_STRUCT_CONVERSION */
30205
30206 #if !defined(USE_STRUCT_CONVERSION)
30207
30208 static NTSTATUS thunk64_vkCmdSetLogicOpEXT(void *args)
30209 {
30210     struct vkCmdSetLogicOpEXT_params *params = args;
30211
30212     TRACE("%p, %#x\n", params->commandBuffer, params->logicOp);
30213
30214     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOp);
30215     return STATUS_SUCCESS;
30216 }
30217
30218 #else /* USE_STRUCT_CONVERSION */
30219
30220 static NTSTATUS thunk32_vkCmdSetLogicOpEXT(void *args)
30221 {
30222     struct
30223     {
30224         VkCommandBuffer commandBuffer;
30225         VkLogicOp logicOp;
30226     } *params = args;
30227
30228     TRACE("%p, %#x\n", params->commandBuffer, params->logicOp);
30229
30230     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOp);
30231     return STATUS_SUCCESS;
30232 }
30233
30234 #endif /* USE_STRUCT_CONVERSION */
30235
30236 #if !defined(USE_STRUCT_CONVERSION)
30237
30238 static NTSTATUS thunk64_vkCmdSetLogicOpEnableEXT(void *args)
30239 {
30240     struct vkCmdSetLogicOpEnableEXT_params *params = args;
30241
30242     TRACE("%p, %u\n", params->commandBuffer, params->logicOpEnable);
30243
30244     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOpEnable);
30245     return STATUS_SUCCESS;
30246 }
30247
30248 #else /* USE_STRUCT_CONVERSION */
30249
30250 static NTSTATUS thunk32_vkCmdSetLogicOpEnableEXT(void *args)
30251 {
30252     struct
30253     {
30254         VkCommandBuffer commandBuffer;
30255         VkBool32 logicOpEnable;
30256     } *params = args;
30257
30258     TRACE("%p, %u\n", params->commandBuffer, params->logicOpEnable);
30259
30260     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOpEnable);
30261     return STATUS_SUCCESS;
30262 }
30263
30264 #endif /* USE_STRUCT_CONVERSION */
30265
30266 #if !defined(USE_STRUCT_CONVERSION)
30267
30268 static NTSTATUS thunk64_vkCmdSetPatchControlPointsEXT(void *args)
30269 {
30270     struct vkCmdSetPatchControlPointsEXT_params *params = args;
30271
30272     TRACE("%p, %u\n", params->commandBuffer, params->patchControlPoints);
30273
30274     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPatchControlPointsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->patchControlPoints);
30275     return STATUS_SUCCESS;
30276 }
30277
30278 #else /* USE_STRUCT_CONVERSION */
30279
30280 static NTSTATUS thunk32_vkCmdSetPatchControlPointsEXT(void *args)
30281 {
30282     struct
30283     {
30284         VkCommandBuffer commandBuffer;
30285         uint32_t patchControlPoints;
30286     } *params = args;
30287
30288     TRACE("%p, %u\n", params->commandBuffer, params->patchControlPoints);
30289
30290     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPatchControlPointsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->patchControlPoints);
30291     return STATUS_SUCCESS;
30292 }
30293
30294 #endif /* USE_STRUCT_CONVERSION */
30295
30296 #if !defined(USE_STRUCT_CONVERSION)
30297
30298 static NTSTATUS thunk64_vkCmdSetPerformanceMarkerINTEL(void *args)
30299 {
30300     struct vkCmdSetPerformanceMarkerINTEL_params *params = args;
30301
30302     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
30303
30304     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
30305     return STATUS_SUCCESS;
30306 }
30307
30308 #else /* USE_STRUCT_CONVERSION */
30309
30310 static NTSTATUS thunk32_vkCmdSetPerformanceMarkerINTEL(void *args)
30311 {
30312     struct
30313     {
30314         VkCommandBuffer commandBuffer;
30315         const VkPerformanceMarkerInfoINTEL32 *pMarkerInfo;
30316         VkResult result;
30317     } *params = args;
30318     VkPerformanceMarkerInfoINTEL pMarkerInfo_host;
30319
30320     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
30321
30322     convert_VkPerformanceMarkerInfoINTEL_win32_to_host(params->pMarkerInfo, &pMarkerInfo_host);
30323     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pMarkerInfo_host);
30324     return STATUS_SUCCESS;
30325 }
30326
30327 #endif /* USE_STRUCT_CONVERSION */
30328
30329 #if !defined(USE_STRUCT_CONVERSION)
30330
30331 static NTSTATUS thunk64_vkCmdSetPerformanceOverrideINTEL(void *args)
30332 {
30333     struct vkCmdSetPerformanceOverrideINTEL_params *params = args;
30334
30335     TRACE("%p, %p\n", params->commandBuffer, params->pOverrideInfo);
30336
30337     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceOverrideINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pOverrideInfo);
30338     return STATUS_SUCCESS;
30339 }
30340
30341 #else /* USE_STRUCT_CONVERSION */
30342
30343 static NTSTATUS thunk32_vkCmdSetPerformanceOverrideINTEL(void *args)
30344 {
30345     struct
30346     {
30347         VkCommandBuffer commandBuffer;
30348         const VkPerformanceOverrideInfoINTEL32 *pOverrideInfo;
30349         VkResult result;
30350     } *params = args;
30351     VkPerformanceOverrideInfoINTEL pOverrideInfo_host;
30352
30353     TRACE("%p, %p\n", params->commandBuffer, params->pOverrideInfo);
30354
30355     convert_VkPerformanceOverrideInfoINTEL_win32_to_host(params->pOverrideInfo, &pOverrideInfo_host);
30356     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceOverrideINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pOverrideInfo_host);
30357     return STATUS_SUCCESS;
30358 }
30359
30360 #endif /* USE_STRUCT_CONVERSION */
30361
30362 #if !defined(USE_STRUCT_CONVERSION)
30363
30364 static NTSTATUS thunk64_vkCmdSetPerformanceStreamMarkerINTEL(void *args)
30365 {
30366     struct vkCmdSetPerformanceStreamMarkerINTEL_params *params = args;
30367
30368     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
30369
30370     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceStreamMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
30371     return STATUS_SUCCESS;
30372 }
30373
30374 #else /* USE_STRUCT_CONVERSION */
30375
30376 static NTSTATUS thunk32_vkCmdSetPerformanceStreamMarkerINTEL(void *args)
30377 {
30378     struct
30379     {
30380         VkCommandBuffer commandBuffer;
30381         const VkPerformanceStreamMarkerInfoINTEL32 *pMarkerInfo;
30382         VkResult result;
30383     } *params = args;
30384     VkPerformanceStreamMarkerInfoINTEL pMarkerInfo_host;
30385
30386     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
30387
30388     convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host(params->pMarkerInfo, &pMarkerInfo_host);
30389     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceStreamMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pMarkerInfo_host);
30390     return STATUS_SUCCESS;
30391 }
30392
30393 #endif /* USE_STRUCT_CONVERSION */
30394
30395 #if !defined(USE_STRUCT_CONVERSION)
30396
30397 static NTSTATUS thunk64_vkCmdSetPolygonModeEXT(void *args)
30398 {
30399     struct vkCmdSetPolygonModeEXT_params *params = args;
30400
30401     TRACE("%p, %#x\n", params->commandBuffer, params->polygonMode);
30402
30403     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPolygonModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->polygonMode);
30404     return STATUS_SUCCESS;
30405 }
30406
30407 #else /* USE_STRUCT_CONVERSION */
30408
30409 static NTSTATUS thunk32_vkCmdSetPolygonModeEXT(void *args)
30410 {
30411     struct
30412     {
30413         VkCommandBuffer commandBuffer;
30414         VkPolygonMode polygonMode;
30415     } *params = args;
30416
30417     TRACE("%p, %#x\n", params->commandBuffer, params->polygonMode);
30418
30419     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPolygonModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->polygonMode);
30420     return STATUS_SUCCESS;
30421 }
30422
30423 #endif /* USE_STRUCT_CONVERSION */
30424
30425 #if !defined(USE_STRUCT_CONVERSION)
30426
30427 static NTSTATUS thunk64_vkCmdSetPrimitiveRestartEnable(void *args)
30428 {
30429     struct vkCmdSetPrimitiveRestartEnable_params *params = args;
30430
30431     TRACE("%p, %u\n", params->commandBuffer, params->primitiveRestartEnable);
30432
30433     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
30434     return STATUS_SUCCESS;
30435 }
30436
30437 #else /* USE_STRUCT_CONVERSION */
30438
30439 static NTSTATUS thunk32_vkCmdSetPrimitiveRestartEnable(void *args)
30440 {
30441     struct
30442     {
30443         VkCommandBuffer commandBuffer;
30444         VkBool32 primitiveRestartEnable;
30445     } *params = args;
30446
30447     TRACE("%p, %u\n", params->commandBuffer, params->primitiveRestartEnable);
30448
30449     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
30450     return STATUS_SUCCESS;
30451 }
30452
30453 #endif /* USE_STRUCT_CONVERSION */
30454
30455 #if !defined(USE_STRUCT_CONVERSION)
30456
30457 static NTSTATUS thunk64_vkCmdSetPrimitiveRestartEnableEXT(void *args)
30458 {
30459     struct vkCmdSetPrimitiveRestartEnableEXT_params *params = args;
30460
30461     TRACE("%p, %u\n", params->commandBuffer, params->primitiveRestartEnable);
30462
30463     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
30464     return STATUS_SUCCESS;
30465 }
30466
30467 #else /* USE_STRUCT_CONVERSION */
30468
30469 static NTSTATUS thunk32_vkCmdSetPrimitiveRestartEnableEXT(void *args)
30470 {
30471     struct
30472     {
30473         VkCommandBuffer commandBuffer;
30474         VkBool32 primitiveRestartEnable;
30475     } *params = args;
30476
30477     TRACE("%p, %u\n", params->commandBuffer, params->primitiveRestartEnable);
30478
30479     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
30480     return STATUS_SUCCESS;
30481 }
30482
30483 #endif /* USE_STRUCT_CONVERSION */
30484
30485 #if !defined(USE_STRUCT_CONVERSION)
30486
30487 static NTSTATUS thunk64_vkCmdSetPrimitiveTopology(void *args)
30488 {
30489     struct vkCmdSetPrimitiveTopology_params *params = args;
30490
30491     TRACE("%p, %#x\n", params->commandBuffer, params->primitiveTopology);
30492
30493     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopology(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
30494     return STATUS_SUCCESS;
30495 }
30496
30497 #else /* USE_STRUCT_CONVERSION */
30498
30499 static NTSTATUS thunk32_vkCmdSetPrimitiveTopology(void *args)
30500 {
30501     struct
30502     {
30503         VkCommandBuffer commandBuffer;
30504         VkPrimitiveTopology primitiveTopology;
30505     } *params = args;
30506
30507     TRACE("%p, %#x\n", params->commandBuffer, params->primitiveTopology);
30508
30509     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopology(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
30510     return STATUS_SUCCESS;
30511 }
30512
30513 #endif /* USE_STRUCT_CONVERSION */
30514
30515 #if !defined(USE_STRUCT_CONVERSION)
30516
30517 static NTSTATUS thunk64_vkCmdSetPrimitiveTopologyEXT(void *args)
30518 {
30519     struct vkCmdSetPrimitiveTopologyEXT_params *params = args;
30520
30521     TRACE("%p, %#x\n", params->commandBuffer, params->primitiveTopology);
30522
30523     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopologyEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
30524     return STATUS_SUCCESS;
30525 }
30526
30527 #else /* USE_STRUCT_CONVERSION */
30528
30529 static NTSTATUS thunk32_vkCmdSetPrimitiveTopologyEXT(void *args)
30530 {
30531     struct
30532     {
30533         VkCommandBuffer commandBuffer;
30534         VkPrimitiveTopology primitiveTopology;
30535     } *params = args;
30536
30537     TRACE("%p, %#x\n", params->commandBuffer, params->primitiveTopology);
30538
30539     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopologyEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
30540     return STATUS_SUCCESS;
30541 }
30542
30543 #endif /* USE_STRUCT_CONVERSION */
30544
30545 #if !defined(USE_STRUCT_CONVERSION)
30546
30547 static NTSTATUS thunk64_vkCmdSetProvokingVertexModeEXT(void *args)
30548 {
30549     struct vkCmdSetProvokingVertexModeEXT_params *params = args;
30550
30551     TRACE("%p, %#x\n", params->commandBuffer, params->provokingVertexMode);
30552
30553     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetProvokingVertexModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->provokingVertexMode);
30554     return STATUS_SUCCESS;
30555 }
30556
30557 #else /* USE_STRUCT_CONVERSION */
30558
30559 static NTSTATUS thunk32_vkCmdSetProvokingVertexModeEXT(void *args)
30560 {
30561     struct
30562     {
30563         VkCommandBuffer commandBuffer;
30564         VkProvokingVertexModeEXT provokingVertexMode;
30565     } *params = args;
30566
30567     TRACE("%p, %#x\n", params->commandBuffer, params->provokingVertexMode);
30568
30569     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetProvokingVertexModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->provokingVertexMode);
30570     return STATUS_SUCCESS;
30571 }
30572
30573 #endif /* USE_STRUCT_CONVERSION */
30574
30575 #if !defined(USE_STRUCT_CONVERSION)
30576
30577 static NTSTATUS thunk64_vkCmdSetRasterizationSamplesEXT(void *args)
30578 {
30579     struct vkCmdSetRasterizationSamplesEXT_params *params = args;
30580
30581     TRACE("%p, %#x\n", params->commandBuffer, params->rasterizationSamples);
30582
30583     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationSamplesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationSamples);
30584     return STATUS_SUCCESS;
30585 }
30586
30587 #else /* USE_STRUCT_CONVERSION */
30588
30589 static NTSTATUS thunk32_vkCmdSetRasterizationSamplesEXT(void *args)
30590 {
30591     struct
30592     {
30593         VkCommandBuffer commandBuffer;
30594         VkSampleCountFlagBits rasterizationSamples;
30595     } *params = args;
30596
30597     TRACE("%p, %#x\n", params->commandBuffer, params->rasterizationSamples);
30598
30599     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationSamplesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationSamples);
30600     return STATUS_SUCCESS;
30601 }
30602
30603 #endif /* USE_STRUCT_CONVERSION */
30604
30605 #if !defined(USE_STRUCT_CONVERSION)
30606
30607 static NTSTATUS thunk64_vkCmdSetRasterizationStreamEXT(void *args)
30608 {
30609     struct vkCmdSetRasterizationStreamEXT_params *params = args;
30610
30611     TRACE("%p, %u\n", params->commandBuffer, params->rasterizationStream);
30612
30613     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationStreamEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationStream);
30614     return STATUS_SUCCESS;
30615 }
30616
30617 #else /* USE_STRUCT_CONVERSION */
30618
30619 static NTSTATUS thunk32_vkCmdSetRasterizationStreamEXT(void *args)
30620 {
30621     struct
30622     {
30623         VkCommandBuffer commandBuffer;
30624         uint32_t rasterizationStream;
30625     } *params = args;
30626
30627     TRACE("%p, %u\n", params->commandBuffer, params->rasterizationStream);
30628
30629     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationStreamEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationStream);
30630     return STATUS_SUCCESS;
30631 }
30632
30633 #endif /* USE_STRUCT_CONVERSION */
30634
30635 #if !defined(USE_STRUCT_CONVERSION)
30636
30637 static NTSTATUS thunk64_vkCmdSetRasterizerDiscardEnable(void *args)
30638 {
30639     struct vkCmdSetRasterizerDiscardEnable_params *params = args;
30640
30641     TRACE("%p, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);
30642
30643     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
30644     return STATUS_SUCCESS;
30645 }
30646
30647 #else /* USE_STRUCT_CONVERSION */
30648
30649 static NTSTATUS thunk32_vkCmdSetRasterizerDiscardEnable(void *args)
30650 {
30651     struct
30652     {
30653         VkCommandBuffer commandBuffer;
30654         VkBool32 rasterizerDiscardEnable;
30655     } *params = args;
30656
30657     TRACE("%p, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);
30658
30659     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
30660     return STATUS_SUCCESS;
30661 }
30662
30663 #endif /* USE_STRUCT_CONVERSION */
30664
30665 #if !defined(USE_STRUCT_CONVERSION)
30666
30667 static NTSTATUS thunk64_vkCmdSetRasterizerDiscardEnableEXT(void *args)
30668 {
30669     struct vkCmdSetRasterizerDiscardEnableEXT_params *params = args;
30670
30671     TRACE("%p, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);
30672
30673     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
30674     return STATUS_SUCCESS;
30675 }
30676
30677 #else /* USE_STRUCT_CONVERSION */
30678
30679 static NTSTATUS thunk32_vkCmdSetRasterizerDiscardEnableEXT(void *args)
30680 {
30681     struct
30682     {
30683         VkCommandBuffer commandBuffer;
30684         VkBool32 rasterizerDiscardEnable;
30685     } *params = args;
30686
30687     TRACE("%p, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);
30688
30689     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
30690     return STATUS_SUCCESS;
30691 }
30692
30693 #endif /* USE_STRUCT_CONVERSION */
30694
30695 #if !defined(USE_STRUCT_CONVERSION)
30696
30697 static NTSTATUS thunk64_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
30698 {
30699     struct vkCmdSetRayTracingPipelineStackSizeKHR_params *params = args;
30700
30701     TRACE("%p, %u\n", params->commandBuffer, params->pipelineStackSize);
30702
30703     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRayTracingPipelineStackSizeKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStackSize);
30704     return STATUS_SUCCESS;
30705 }
30706
30707 #else /* USE_STRUCT_CONVERSION */
30708
30709 static NTSTATUS thunk32_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
30710 {
30711     struct
30712     {
30713         VkCommandBuffer commandBuffer;
30714         uint32_t pipelineStackSize;
30715     } *params = args;
30716
30717     TRACE("%p, %u\n", params->commandBuffer, params->pipelineStackSize);
30718
30719     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRayTracingPipelineStackSizeKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStackSize);
30720     return STATUS_SUCCESS;
30721 }
30722
30723 #endif /* USE_STRUCT_CONVERSION */
30724
30725 #if !defined(USE_STRUCT_CONVERSION)
30726
30727 static NTSTATUS thunk64_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
30728 {
30729     struct vkCmdSetRepresentativeFragmentTestEnableNV_params *params = args;
30730
30731     TRACE("%p, %u\n", params->commandBuffer, params->representativeFragmentTestEnable);
30732
30733     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRepresentativeFragmentTestEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->representativeFragmentTestEnable);
30734     return STATUS_SUCCESS;
30735 }
30736
30737 #else /* USE_STRUCT_CONVERSION */
30738
30739 static NTSTATUS thunk32_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
30740 {
30741     struct
30742     {
30743         VkCommandBuffer commandBuffer;
30744         VkBool32 representativeFragmentTestEnable;
30745     } *params = args;
30746
30747     TRACE("%p, %u\n", params->commandBuffer, params->representativeFragmentTestEnable);
30748
30749     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRepresentativeFragmentTestEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->representativeFragmentTestEnable);
30750     return STATUS_SUCCESS;
30751 }
30752
30753 #endif /* USE_STRUCT_CONVERSION */
30754
30755 #if !defined(USE_STRUCT_CONVERSION)
30756
30757 static NTSTATUS thunk64_vkCmdSetSampleLocationsEXT(void *args)
30758 {
30759     struct vkCmdSetSampleLocationsEXT_params *params = args;
30760
30761     TRACE("%p, %p\n", params->commandBuffer, params->pSampleLocationsInfo);
30762
30763     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSampleLocationsInfo);
30764     return STATUS_SUCCESS;
30765 }
30766
30767 #else /* USE_STRUCT_CONVERSION */
30768
30769 static NTSTATUS thunk32_vkCmdSetSampleLocationsEXT(void *args)
30770 {
30771     struct
30772     {
30773         VkCommandBuffer commandBuffer;
30774         const VkSampleLocationsInfoEXT32 *pSampleLocationsInfo;
30775     } *params = args;
30776     VkSampleLocationsInfoEXT pSampleLocationsInfo_host;
30777
30778     TRACE("%p, %p\n", params->commandBuffer, params->pSampleLocationsInfo);
30779
30780     convert_VkSampleLocationsInfoEXT_win32_to_host(params->pSampleLocationsInfo, &pSampleLocationsInfo_host);
30781     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pSampleLocationsInfo_host);
30782     return STATUS_SUCCESS;
30783 }
30784
30785 #endif /* USE_STRUCT_CONVERSION */
30786
30787 #if !defined(USE_STRUCT_CONVERSION)
30788
30789 static NTSTATUS thunk64_vkCmdSetSampleLocationsEnableEXT(void *args)
30790 {
30791     struct vkCmdSetSampleLocationsEnableEXT_params *params = args;
30792
30793     TRACE("%p, %u\n", params->commandBuffer, params->sampleLocationsEnable);
30794
30795     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->sampleLocationsEnable);
30796     return STATUS_SUCCESS;
30797 }
30798
30799 #else /* USE_STRUCT_CONVERSION */
30800
30801 static NTSTATUS thunk32_vkCmdSetSampleLocationsEnableEXT(void *args)
30802 {
30803     struct
30804     {
30805         VkCommandBuffer commandBuffer;
30806         VkBool32 sampleLocationsEnable;
30807     } *params = args;
30808
30809     TRACE("%p, %u\n", params->commandBuffer, params->sampleLocationsEnable);
30810
30811     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->sampleLocationsEnable);
30812     return STATUS_SUCCESS;
30813 }
30814
30815 #endif /* USE_STRUCT_CONVERSION */
30816
30817 #if !defined(USE_STRUCT_CONVERSION)
30818
30819 static NTSTATUS thunk64_vkCmdSetSampleMaskEXT(void *args)
30820 {
30821     struct vkCmdSetSampleMaskEXT_params *params = args;
30822
30823     TRACE("%p, %#x, %p\n", params->commandBuffer, params->samples, params->pSampleMask);
30824
30825     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->samples, params->pSampleMask);
30826     return STATUS_SUCCESS;
30827 }
30828
30829 #else /* USE_STRUCT_CONVERSION */
30830
30831 static NTSTATUS thunk32_vkCmdSetSampleMaskEXT(void *args)
30832 {
30833     struct
30834     {
30835         VkCommandBuffer commandBuffer;
30836         VkSampleCountFlagBits samples;
30837         const VkSampleMask *pSampleMask;
30838     } *params = args;
30839
30840     TRACE("%p, %#x, %p\n", params->commandBuffer, params->samples, params->pSampleMask);
30841
30842     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->samples, params->pSampleMask);
30843     return STATUS_SUCCESS;
30844 }
30845
30846 #endif /* USE_STRUCT_CONVERSION */
30847
30848 #if !defined(USE_STRUCT_CONVERSION)
30849
30850 static NTSTATUS thunk64_vkCmdSetScissor(void *args)
30851 {
30852     struct vkCmdSetScissor_params *params = args;
30853
30854     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstScissor, params->scissorCount, params->pScissors);
30855
30856     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissor(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstScissor, params->scissorCount, params->pScissors);
30857     return STATUS_SUCCESS;
30858 }
30859
30860 #else /* USE_STRUCT_CONVERSION */
30861
30862 static NTSTATUS thunk32_vkCmdSetScissor(void *args)
30863 {
30864     struct
30865     {
30866         VkCommandBuffer commandBuffer;
30867         uint32_t firstScissor;
30868         uint32_t scissorCount;
30869         const VkRect2D *pScissors;
30870     } *params = args;
30871
30872     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstScissor, params->scissorCount, params->pScissors);
30873
30874     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissor(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstScissor, params->scissorCount, params->pScissors);
30875     return STATUS_SUCCESS;
30876 }
30877
30878 #endif /* USE_STRUCT_CONVERSION */
30879
30880 #if !defined(USE_STRUCT_CONVERSION)
30881
30882 static NTSTATUS thunk64_vkCmdSetScissorWithCount(void *args)
30883 {
30884     struct vkCmdSetScissorWithCount_params *params = args;
30885
30886     TRACE("%p, %u, %p\n", params->commandBuffer, params->scissorCount, params->pScissors);
30887
30888     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
30889     return STATUS_SUCCESS;
30890 }
30891
30892 #else /* USE_STRUCT_CONVERSION */
30893
30894 static NTSTATUS thunk32_vkCmdSetScissorWithCount(void *args)
30895 {
30896     struct
30897     {
30898         VkCommandBuffer commandBuffer;
30899         uint32_t scissorCount;
30900         const VkRect2D *pScissors;
30901     } *params = args;
30902
30903     TRACE("%p, %u, %p\n", params->commandBuffer, params->scissorCount, params->pScissors);
30904
30905     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
30906     return STATUS_SUCCESS;
30907 }
30908
30909 #endif /* USE_STRUCT_CONVERSION */
30910
30911 #if !defined(USE_STRUCT_CONVERSION)
30912
30913 static NTSTATUS thunk64_vkCmdSetScissorWithCountEXT(void *args)
30914 {
30915     struct vkCmdSetScissorWithCountEXT_params *params = args;
30916
30917     TRACE("%p, %u, %p\n", params->commandBuffer, params->scissorCount, params->pScissors);
30918
30919     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
30920     return STATUS_SUCCESS;
30921 }
30922
30923 #else /* USE_STRUCT_CONVERSION */
30924
30925 static NTSTATUS thunk32_vkCmdSetScissorWithCountEXT(void *args)
30926 {
30927     struct
30928     {
30929         VkCommandBuffer commandBuffer;
30930         uint32_t scissorCount;
30931         const VkRect2D *pScissors;
30932     } *params = args;
30933
30934     TRACE("%p, %u, %p\n", params->commandBuffer, params->scissorCount, params->pScissors);
30935
30936     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
30937     return STATUS_SUCCESS;
30938 }
30939
30940 #endif /* USE_STRUCT_CONVERSION */
30941
30942 #if !defined(USE_STRUCT_CONVERSION)
30943
30944 static NTSTATUS thunk64_vkCmdSetShadingRateImageEnableNV(void *args)
30945 {
30946     struct vkCmdSetShadingRateImageEnableNV_params *params = args;
30947
30948     TRACE("%p, %u\n", params->commandBuffer, params->shadingRateImageEnable);
30949
30950     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetShadingRateImageEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRateImageEnable);
30951     return STATUS_SUCCESS;
30952 }
30953
30954 #else /* USE_STRUCT_CONVERSION */
30955
30956 static NTSTATUS thunk32_vkCmdSetShadingRateImageEnableNV(void *args)
30957 {
30958     struct
30959     {
30960         VkCommandBuffer commandBuffer;
30961         VkBool32 shadingRateImageEnable;
30962     } *params = args;
30963
30964     TRACE("%p, %u\n", params->commandBuffer, params->shadingRateImageEnable);
30965
30966     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetShadingRateImageEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRateImageEnable);
30967     return STATUS_SUCCESS;
30968 }
30969
30970 #endif /* USE_STRUCT_CONVERSION */
30971
30972 #if !defined(USE_STRUCT_CONVERSION)
30973
30974 static NTSTATUS thunk64_vkCmdSetStencilCompareMask(void *args)
30975 {
30976     struct vkCmdSetStencilCompareMask_params *params = args;
30977
30978     TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->compareMask);
30979
30980     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilCompareMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->compareMask);
30981     return STATUS_SUCCESS;
30982 }
30983
30984 #else /* USE_STRUCT_CONVERSION */
30985
30986 static NTSTATUS thunk32_vkCmdSetStencilCompareMask(void *args)
30987 {
30988     struct
30989     {
30990         VkCommandBuffer commandBuffer;
30991         VkStencilFaceFlags faceMask;
30992         uint32_t compareMask;
30993     } *params = args;
30994
30995     TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->compareMask);
30996
30997     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilCompareMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->compareMask);
30998     return STATUS_SUCCESS;
30999 }
31000
31001 #endif /* USE_STRUCT_CONVERSION */
31002
31003 #if !defined(USE_STRUCT_CONVERSION)
31004
31005 static NTSTATUS thunk64_vkCmdSetStencilOp(void *args)
31006 {
31007     struct vkCmdSetStencilOp_params *params = args;
31008
31009     TRACE("%p, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
31010
31011     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
31012     return STATUS_SUCCESS;
31013 }
31014
31015 #else /* USE_STRUCT_CONVERSION */
31016
31017 static NTSTATUS thunk32_vkCmdSetStencilOp(void *args)
31018 {
31019     struct
31020     {
31021         VkCommandBuffer commandBuffer;
31022         VkStencilFaceFlags faceMask;
31023         VkStencilOp failOp;
31024         VkStencilOp passOp;
31025         VkStencilOp depthFailOp;
31026         VkCompareOp compareOp;
31027     } *params = args;
31028
31029     TRACE("%p, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
31030
31031     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
31032     return STATUS_SUCCESS;
31033 }
31034
31035 #endif /* USE_STRUCT_CONVERSION */
31036
31037 #if !defined(USE_STRUCT_CONVERSION)
31038
31039 static NTSTATUS thunk64_vkCmdSetStencilOpEXT(void *args)
31040 {
31041     struct vkCmdSetStencilOpEXT_params *params = args;
31042
31043     TRACE("%p, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
31044
31045     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
31046     return STATUS_SUCCESS;
31047 }
31048
31049 #else /* USE_STRUCT_CONVERSION */
31050
31051 static NTSTATUS thunk32_vkCmdSetStencilOpEXT(void *args)
31052 {
31053     struct
31054     {
31055         VkCommandBuffer commandBuffer;
31056         VkStencilFaceFlags faceMask;
31057         VkStencilOp failOp;
31058         VkStencilOp passOp;
31059         VkStencilOp depthFailOp;
31060         VkCompareOp compareOp;
31061     } *params = args;
31062
31063     TRACE("%p, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
31064
31065     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
31066     return STATUS_SUCCESS;
31067 }
31068
31069 #endif /* USE_STRUCT_CONVERSION */
31070
31071 #if !defined(USE_STRUCT_CONVERSION)
31072
31073 static NTSTATUS thunk64_vkCmdSetStencilReference(void *args)
31074 {
31075     struct vkCmdSetStencilReference_params *params = args;
31076
31077     TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->reference);
31078
31079     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilReference(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->reference);
31080     return STATUS_SUCCESS;
31081 }
31082
31083 #else /* USE_STRUCT_CONVERSION */
31084
31085 static NTSTATUS thunk32_vkCmdSetStencilReference(void *args)
31086 {
31087     struct
31088     {
31089         VkCommandBuffer commandBuffer;
31090         VkStencilFaceFlags faceMask;
31091         uint32_t reference;
31092     } *params = args;
31093
31094     TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->reference);
31095
31096     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilReference(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->reference);
31097     return STATUS_SUCCESS;
31098 }
31099
31100 #endif /* USE_STRUCT_CONVERSION */
31101
31102 #if !defined(USE_STRUCT_CONVERSION)
31103
31104 static NTSTATUS thunk64_vkCmdSetStencilTestEnable(void *args)
31105 {
31106     struct vkCmdSetStencilTestEnable_params *params = args;
31107
31108     TRACE("%p, %u\n", params->commandBuffer, params->stencilTestEnable);
31109
31110     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
31111     return STATUS_SUCCESS;
31112 }
31113
31114 #else /* USE_STRUCT_CONVERSION */
31115
31116 static NTSTATUS thunk32_vkCmdSetStencilTestEnable(void *args)
31117 {
31118     struct
31119     {
31120         VkCommandBuffer commandBuffer;
31121         VkBool32 stencilTestEnable;
31122     } *params = args;
31123
31124     TRACE("%p, %u\n", params->commandBuffer, params->stencilTestEnable);
31125
31126     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
31127     return STATUS_SUCCESS;
31128 }
31129
31130 #endif /* USE_STRUCT_CONVERSION */
31131
31132 #if !defined(USE_STRUCT_CONVERSION)
31133
31134 static NTSTATUS thunk64_vkCmdSetStencilTestEnableEXT(void *args)
31135 {
31136     struct vkCmdSetStencilTestEnableEXT_params *params = args;
31137
31138     TRACE("%p, %u\n", params->commandBuffer, params->stencilTestEnable);
31139
31140     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
31141     return STATUS_SUCCESS;
31142 }
31143
31144 #else /* USE_STRUCT_CONVERSION */
31145
31146 static NTSTATUS thunk32_vkCmdSetStencilTestEnableEXT(void *args)
31147 {
31148     struct
31149     {
31150         VkCommandBuffer commandBuffer;
31151         VkBool32 stencilTestEnable;
31152     } *params = args;
31153
31154     TRACE("%p, %u\n", params->commandBuffer, params->stencilTestEnable);
31155
31156     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
31157     return STATUS_SUCCESS;
31158 }
31159
31160 #endif /* USE_STRUCT_CONVERSION */
31161
31162 #if !defined(USE_STRUCT_CONVERSION)
31163
31164 static NTSTATUS thunk64_vkCmdSetStencilWriteMask(void *args)
31165 {
31166     struct vkCmdSetStencilWriteMask_params *params = args;
31167
31168     TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->writeMask);
31169
31170     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilWriteMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->writeMask);
31171     return STATUS_SUCCESS;
31172 }
31173
31174 #else /* USE_STRUCT_CONVERSION */
31175
31176 static NTSTATUS thunk32_vkCmdSetStencilWriteMask(void *args)
31177 {
31178     struct
31179     {
31180         VkCommandBuffer commandBuffer;
31181         VkStencilFaceFlags faceMask;
31182         uint32_t writeMask;
31183     } *params = args;
31184
31185     TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->writeMask);
31186
31187     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilWriteMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->writeMask);
31188     return STATUS_SUCCESS;
31189 }
31190
31191 #endif /* USE_STRUCT_CONVERSION */
31192
31193 #if !defined(USE_STRUCT_CONVERSION)
31194
31195 static NTSTATUS thunk64_vkCmdSetTessellationDomainOriginEXT(void *args)
31196 {
31197     struct vkCmdSetTessellationDomainOriginEXT_params *params = args;
31198
31199     TRACE("%p, %#x\n", params->commandBuffer, params->domainOrigin);
31200
31201     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetTessellationDomainOriginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->domainOrigin);
31202     return STATUS_SUCCESS;
31203 }
31204
31205 #else /* USE_STRUCT_CONVERSION */
31206
31207 static NTSTATUS thunk32_vkCmdSetTessellationDomainOriginEXT(void *args)
31208 {
31209     struct
31210     {
31211         VkCommandBuffer commandBuffer;
31212         VkTessellationDomainOrigin domainOrigin;
31213     } *params = args;
31214
31215     TRACE("%p, %#x\n", params->commandBuffer, params->domainOrigin);
31216
31217     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetTessellationDomainOriginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->domainOrigin);
31218     return STATUS_SUCCESS;
31219 }
31220
31221 #endif /* USE_STRUCT_CONVERSION */
31222
31223 #if !defined(USE_STRUCT_CONVERSION)
31224
31225 static NTSTATUS thunk64_vkCmdSetVertexInputEXT(void *args)
31226 {
31227     struct vkCmdSetVertexInputEXT_params *params = args;
31228
31229     TRACE("%p, %u, %p, %u, %p\n", params->commandBuffer, params->vertexBindingDescriptionCount, params->pVertexBindingDescriptions, params->vertexAttributeDescriptionCount, params->pVertexAttributeDescriptions);
31230
31231     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetVertexInputEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->vertexBindingDescriptionCount, params->pVertexBindingDescriptions, params->vertexAttributeDescriptionCount, params->pVertexAttributeDescriptions);
31232     return STATUS_SUCCESS;
31233 }
31234
31235 #else /* USE_STRUCT_CONVERSION */
31236
31237 static NTSTATUS thunk32_vkCmdSetVertexInputEXT(void *args)
31238 {
31239     struct
31240     {
31241         VkCommandBuffer commandBuffer;
31242         uint32_t vertexBindingDescriptionCount;
31243         const VkVertexInputBindingDescription2EXT32 *pVertexBindingDescriptions;
31244         uint32_t vertexAttributeDescriptionCount;
31245         const VkVertexInputAttributeDescription2EXT32 *pVertexAttributeDescriptions;
31246     } *params = args;
31247     const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions_host;
31248     const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions_host;
31249     struct conversion_context ctx;
31250
31251     TRACE("%p, %u, %p, %u, %p\n", params->commandBuffer, params->vertexBindingDescriptionCount, params->pVertexBindingDescriptions, params->vertexAttributeDescriptionCount, params->pVertexAttributeDescriptions);
31252
31253     init_conversion_context(&ctx);
31254     pVertexBindingDescriptions_host = convert_VkVertexInputBindingDescription2EXT_array_win32_to_host(&ctx, params->pVertexBindingDescriptions, params->vertexBindingDescriptionCount);
31255     pVertexAttributeDescriptions_host = convert_VkVertexInputAttributeDescription2EXT_array_win32_to_host(&ctx, params->pVertexAttributeDescriptions, params->vertexAttributeDescriptionCount);
31256     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetVertexInputEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->vertexBindingDescriptionCount, pVertexBindingDescriptions_host, params->vertexAttributeDescriptionCount, pVertexAttributeDescriptions_host);
31257     free_conversion_context(&ctx);
31258     return STATUS_SUCCESS;
31259 }
31260
31261 #endif /* USE_STRUCT_CONVERSION */
31262
31263 #if !defined(USE_STRUCT_CONVERSION)
31264
31265 static NTSTATUS thunk64_vkCmdSetViewport(void *args)
31266 {
31267     struct vkCmdSetViewport_params *params = args;
31268
31269     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewports);
31270
31271     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewport(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pViewports);
31272     return STATUS_SUCCESS;
31273 }
31274
31275 #else /* USE_STRUCT_CONVERSION */
31276
31277 static NTSTATUS thunk32_vkCmdSetViewport(void *args)
31278 {
31279     struct
31280     {
31281         VkCommandBuffer commandBuffer;
31282         uint32_t firstViewport;
31283         uint32_t viewportCount;
31284         const VkViewport *pViewports;
31285     } *params = args;
31286
31287     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewports);
31288
31289     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewport(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pViewports);
31290     return STATUS_SUCCESS;
31291 }
31292
31293 #endif /* USE_STRUCT_CONVERSION */
31294
31295 #if !defined(USE_STRUCT_CONVERSION)
31296
31297 static NTSTATUS thunk64_vkCmdSetViewportShadingRatePaletteNV(void *args)
31298 {
31299     struct vkCmdSetViewportShadingRatePaletteNV_params *params = args;
31300
31301     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pShadingRatePalettes);
31302
31303     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportShadingRatePaletteNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pShadingRatePalettes);
31304     return STATUS_SUCCESS;
31305 }
31306
31307 #else /* USE_STRUCT_CONVERSION */
31308
31309 static NTSTATUS thunk32_vkCmdSetViewportShadingRatePaletteNV(void *args)
31310 {
31311     struct
31312     {
31313         VkCommandBuffer commandBuffer;
31314         uint32_t firstViewport;
31315         uint32_t viewportCount;
31316         const VkShadingRatePaletteNV *pShadingRatePalettes;
31317     } *params = args;
31318
31319     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pShadingRatePalettes);
31320
31321     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportShadingRatePaletteNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pShadingRatePalettes);
31322     return STATUS_SUCCESS;
31323 }
31324
31325 #endif /* USE_STRUCT_CONVERSION */
31326
31327 #if !defined(USE_STRUCT_CONVERSION)
31328
31329 static NTSTATUS thunk64_vkCmdSetViewportSwizzleNV(void *args)
31330 {
31331     struct vkCmdSetViewportSwizzleNV_params *params = args;
31332
31333     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportSwizzles);
31334
31335     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportSwizzleNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pViewportSwizzles);
31336     return STATUS_SUCCESS;
31337 }
31338
31339 #else /* USE_STRUCT_CONVERSION */
31340
31341 static NTSTATUS thunk32_vkCmdSetViewportSwizzleNV(void *args)
31342 {
31343     struct
31344     {
31345         VkCommandBuffer commandBuffer;
31346         uint32_t firstViewport;
31347         uint32_t viewportCount;
31348         const VkViewportSwizzleNV *pViewportSwizzles;
31349     } *params = args;
31350
31351     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportSwizzles);
31352
31353     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportSwizzleNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pViewportSwizzles);
31354     return STATUS_SUCCESS;
31355 }
31356
31357 #endif /* USE_STRUCT_CONVERSION */
31358
31359 #if !defined(USE_STRUCT_CONVERSION)
31360
31361 static NTSTATUS thunk64_vkCmdSetViewportWScalingEnableNV(void *args)
31362 {
31363     struct vkCmdSetViewportWScalingEnableNV_params *params = args;
31364
31365     TRACE("%p, %u\n", params->commandBuffer, params->viewportWScalingEnable);
31366
31367     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWScalingEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportWScalingEnable);
31368     return STATUS_SUCCESS;
31369 }
31370
31371 #else /* USE_STRUCT_CONVERSION */
31372
31373 static NTSTATUS thunk32_vkCmdSetViewportWScalingEnableNV(void *args)
31374 {
31375     struct
31376     {
31377         VkCommandBuffer commandBuffer;
31378         VkBool32 viewportWScalingEnable;
31379     } *params = args;
31380
31381     TRACE("%p, %u\n", params->commandBuffer, params->viewportWScalingEnable);
31382
31383     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWScalingEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportWScalingEnable);
31384     return STATUS_SUCCESS;
31385 }
31386
31387 #endif /* USE_STRUCT_CONVERSION */
31388
31389 #if !defined(USE_STRUCT_CONVERSION)
31390
31391 static NTSTATUS thunk64_vkCmdSetViewportWScalingNV(void *args)
31392 {
31393     struct vkCmdSetViewportWScalingNV_params *params = args;
31394
31395     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportWScalings);
31396
31397     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWScalingNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pViewportWScalings);
31398     return STATUS_SUCCESS;
31399 }
31400
31401 #else /* USE_STRUCT_CONVERSION */
31402
31403 static NTSTATUS thunk32_vkCmdSetViewportWScalingNV(void *args)
31404 {
31405     struct
31406     {
31407         VkCommandBuffer commandBuffer;
31408         uint32_t firstViewport;
31409         uint32_t viewportCount;
31410         const VkViewportWScalingNV *pViewportWScalings;
31411     } *params = args;
31412
31413     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportWScalings);
31414
31415     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWScalingNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pViewportWScalings);
31416     return STATUS_SUCCESS;
31417 }
31418
31419 #endif /* USE_STRUCT_CONVERSION */
31420
31421 #if !defined(USE_STRUCT_CONVERSION)
31422
31423 static NTSTATUS thunk64_vkCmdSetViewportWithCount(void *args)
31424 {
31425     struct vkCmdSetViewportWithCount_params *params = args;
31426
31427     TRACE("%p, %u, %p\n", params->commandBuffer, params->viewportCount, params->pViewports);
31428
31429     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
31430     return STATUS_SUCCESS;
31431 }
31432
31433 #else /* USE_STRUCT_CONVERSION */
31434
31435 static NTSTATUS thunk32_vkCmdSetViewportWithCount(void *args)
31436 {
31437     struct
31438     {
31439         VkCommandBuffer commandBuffer;
31440         uint32_t viewportCount;
31441         const VkViewport *pViewports;
31442     } *params = args;
31443
31444     TRACE("%p, %u, %p\n", params->commandBuffer, params->viewportCount, params->pViewports);
31445
31446     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
31447     return STATUS_SUCCESS;
31448 }
31449
31450 #endif /* USE_STRUCT_CONVERSION */
31451
31452 #if !defined(USE_STRUCT_CONVERSION)
31453
31454 static NTSTATUS thunk64_vkCmdSetViewportWithCountEXT(void *args)
31455 {
31456     struct vkCmdSetViewportWithCountEXT_params *params = args;
31457
31458     TRACE("%p, %u, %p\n", params->commandBuffer, params->viewportCount, params->pViewports);
31459
31460     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
31461     return STATUS_SUCCESS;
31462 }
31463
31464 #else /* USE_STRUCT_CONVERSION */
31465
31466 static NTSTATUS thunk32_vkCmdSetViewportWithCountEXT(void *args)
31467 {
31468     struct
31469     {
31470         VkCommandBuffer commandBuffer;
31471         uint32_t viewportCount;
31472         const VkViewport *pViewports;
31473     } *params = args;
31474
31475     TRACE("%p, %u, %p\n", params->commandBuffer, params->viewportCount, params->pViewports);
31476
31477     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
31478     return STATUS_SUCCESS;
31479 }
31480
31481 #endif /* USE_STRUCT_CONVERSION */
31482
31483 #if !defined(USE_STRUCT_CONVERSION)
31484
31485 static NTSTATUS thunk64_vkCmdSubpassShadingHUAWEI(void *args)
31486 {
31487     struct vkCmdSubpassShadingHUAWEI_params *params = args;
31488
31489     TRACE("%p\n", params->commandBuffer);
31490
31491     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSubpassShadingHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
31492     return STATUS_SUCCESS;
31493 }
31494
31495 #else /* USE_STRUCT_CONVERSION */
31496
31497 static NTSTATUS thunk32_vkCmdSubpassShadingHUAWEI(void *args)
31498 {
31499     struct
31500     {
31501         VkCommandBuffer commandBuffer;
31502     } *params = args;
31503
31504     TRACE("%p\n", params->commandBuffer);
31505
31506     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSubpassShadingHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
31507     return STATUS_SUCCESS;
31508 }
31509
31510 #endif /* USE_STRUCT_CONVERSION */
31511
31512 #if !defined(USE_STRUCT_CONVERSION)
31513
31514 static NTSTATUS thunk64_vkCmdTraceRaysIndirect2KHR(void *args)
31515 {
31516     struct vkCmdTraceRaysIndirect2KHR_params *params = args;
31517
31518     TRACE("%p, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectDeviceAddress));
31519
31520     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysIndirect2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indirectDeviceAddress);
31521     return STATUS_SUCCESS;
31522 }
31523
31524 #else /* USE_STRUCT_CONVERSION */
31525
31526 static NTSTATUS thunk32_vkCmdTraceRaysIndirect2KHR(void *args)
31527 {
31528     struct
31529     {
31530         VkCommandBuffer commandBuffer;
31531         VkDeviceAddress DECLSPEC_ALIGN(8) indirectDeviceAddress;
31532     } *params = args;
31533
31534     TRACE("%p, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectDeviceAddress));
31535
31536     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysIndirect2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indirectDeviceAddress);
31537     return STATUS_SUCCESS;
31538 }
31539
31540 #endif /* USE_STRUCT_CONVERSION */
31541
31542 #if !defined(USE_STRUCT_CONVERSION)
31543
31544 static NTSTATUS thunk64_vkCmdTraceRaysIndirectKHR(void *args)
31545 {
31546     struct vkCmdTraceRaysIndirectKHR_params *params = args;
31547
31548     TRACE("%p, %p, %p, %p, %p, 0x%s\n", params->commandBuffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, wine_dbgstr_longlong(params->indirectDeviceAddress));
31549
31550     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysIndirectKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, params->indirectDeviceAddress);
31551     return STATUS_SUCCESS;
31552 }
31553
31554 #else /* USE_STRUCT_CONVERSION */
31555
31556 static NTSTATUS thunk32_vkCmdTraceRaysIndirectKHR(void *args)
31557 {
31558     struct
31559     {
31560         VkCommandBuffer commandBuffer;
31561         const VkStridedDeviceAddressRegionKHR32 *pRaygenShaderBindingTable;
31562         const VkStridedDeviceAddressRegionKHR32 *pMissShaderBindingTable;
31563         const VkStridedDeviceAddressRegionKHR32 *pHitShaderBindingTable;
31564         const VkStridedDeviceAddressRegionKHR32 *pCallableShaderBindingTable;
31565         VkDeviceAddress DECLSPEC_ALIGN(8) indirectDeviceAddress;
31566     } *params = args;
31567     VkStridedDeviceAddressRegionKHR pRaygenShaderBindingTable_host;
31568     VkStridedDeviceAddressRegionKHR pMissShaderBindingTable_host;
31569     VkStridedDeviceAddressRegionKHR pHitShaderBindingTable_host;
31570     VkStridedDeviceAddressRegionKHR pCallableShaderBindingTable_host;
31571
31572     TRACE("%p, %p, %p, %p, %p, 0x%s\n", params->commandBuffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, wine_dbgstr_longlong(params->indirectDeviceAddress));
31573
31574     convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pRaygenShaderBindingTable, &pRaygenShaderBindingTable_host);
31575     convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pMissShaderBindingTable, &pMissShaderBindingTable_host);
31576     convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pHitShaderBindingTable, &pHitShaderBindingTable_host);
31577     convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pCallableShaderBindingTable, &pCallableShaderBindingTable_host);
31578     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysIndirectKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRaygenShaderBindingTable_host, &pMissShaderBindingTable_host, &pHitShaderBindingTable_host, &pCallableShaderBindingTable_host, params->indirectDeviceAddress);
31579     return STATUS_SUCCESS;
31580 }
31581
31582 #endif /* USE_STRUCT_CONVERSION */
31583
31584 #if !defined(USE_STRUCT_CONVERSION)
31585
31586 static NTSTATUS thunk64_vkCmdTraceRaysKHR(void *args)
31587 {
31588     struct vkCmdTraceRaysKHR_params *params = args;
31589
31590     TRACE("%p, %p, %p, %p, %p, %u, %u, %u\n", params->commandBuffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, params->width, params->height, params->depth);
31591
31592     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, params->width, params->height, params->depth);
31593     return STATUS_SUCCESS;
31594 }
31595
31596 #else /* USE_STRUCT_CONVERSION */
31597
31598 static NTSTATUS thunk32_vkCmdTraceRaysKHR(void *args)
31599 {
31600     struct
31601     {
31602         VkCommandBuffer commandBuffer;
31603         const VkStridedDeviceAddressRegionKHR32 *pRaygenShaderBindingTable;
31604         const VkStridedDeviceAddressRegionKHR32 *pMissShaderBindingTable;
31605         const VkStridedDeviceAddressRegionKHR32 *pHitShaderBindingTable;
31606         const VkStridedDeviceAddressRegionKHR32 *pCallableShaderBindingTable;
31607         uint32_t width;
31608         uint32_t height;
31609         uint32_t depth;
31610     } *params = args;
31611     VkStridedDeviceAddressRegionKHR pRaygenShaderBindingTable_host;
31612     VkStridedDeviceAddressRegionKHR pMissShaderBindingTable_host;
31613     VkStridedDeviceAddressRegionKHR pHitShaderBindingTable_host;
31614     VkStridedDeviceAddressRegionKHR pCallableShaderBindingTable_host;
31615
31616     TRACE("%p, %p, %p, %p, %p, %u, %u, %u\n", params->commandBuffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, params->width, params->height, params->depth);
31617
31618     convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pRaygenShaderBindingTable, &pRaygenShaderBindingTable_host);
31619     convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pMissShaderBindingTable, &pMissShaderBindingTable_host);
31620     convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pHitShaderBindingTable, &pHitShaderBindingTable_host);
31621     convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pCallableShaderBindingTable, &pCallableShaderBindingTable_host);
31622     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRaygenShaderBindingTable_host, &pMissShaderBindingTable_host, &pHitShaderBindingTable_host, &pCallableShaderBindingTable_host, params->width, params->height, params->depth);
31623     return STATUS_SUCCESS;
31624 }
31625
31626 #endif /* USE_STRUCT_CONVERSION */
31627
31628 #if !defined(USE_STRUCT_CONVERSION)
31629
31630 static NTSTATUS thunk64_vkCmdTraceRaysNV(void *args)
31631 {
31632     struct vkCmdTraceRaysNV_params *params = args;
31633
31634     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->raygenShaderBindingTableBuffer), wine_dbgstr_longlong(params->raygenShaderBindingOffset), wine_dbgstr_longlong(params->missShaderBindingTableBuffer), wine_dbgstr_longlong(params->missShaderBindingOffset), wine_dbgstr_longlong(params->missShaderBindingStride), wine_dbgstr_longlong(params->hitShaderBindingTableBuffer), wine_dbgstr_longlong(params->hitShaderBindingOffset), wine_dbgstr_longlong(params->hitShaderBindingStride), wine_dbgstr_longlong(params->callableShaderBindingTableBuffer), wine_dbgstr_longlong(params->callableShaderBindingOffset), wine_dbgstr_longlong(params->callableShaderBindingStride), params->width, params->height, params->depth);
31635
31636     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->raygenShaderBindingTableBuffer, params->raygenShaderBindingOffset, params->missShaderBindingTableBuffer, params->missShaderBindingOffset, params->missShaderBindingStride, params->hitShaderBindingTableBuffer, params->hitShaderBindingOffset, params->hitShaderBindingStride, params->callableShaderBindingTableBuffer, params->callableShaderBindingOffset, params->callableShaderBindingStride, params->width, params->height, params->depth);
31637     return STATUS_SUCCESS;
31638 }
31639
31640 #else /* USE_STRUCT_CONVERSION */
31641
31642 static NTSTATUS thunk32_vkCmdTraceRaysNV(void *args)
31643 {
31644     struct
31645     {
31646         VkCommandBuffer commandBuffer;
31647         VkBuffer DECLSPEC_ALIGN(8) raygenShaderBindingTableBuffer;
31648         VkDeviceSize DECLSPEC_ALIGN(8) raygenShaderBindingOffset;
31649         VkBuffer DECLSPEC_ALIGN(8) missShaderBindingTableBuffer;
31650         VkDeviceSize DECLSPEC_ALIGN(8) missShaderBindingOffset;
31651         VkDeviceSize DECLSPEC_ALIGN(8) missShaderBindingStride;
31652         VkBuffer DECLSPEC_ALIGN(8) hitShaderBindingTableBuffer;
31653         VkDeviceSize DECLSPEC_ALIGN(8) hitShaderBindingOffset;
31654         VkDeviceSize DECLSPEC_ALIGN(8) hitShaderBindingStride;
31655         VkBuffer DECLSPEC_ALIGN(8) callableShaderBindingTableBuffer;
31656         VkDeviceSize DECLSPEC_ALIGN(8) callableShaderBindingOffset;
31657         VkDeviceSize DECLSPEC_ALIGN(8) callableShaderBindingStride;
31658         uint32_t width;
31659         uint32_t height;
31660         uint32_t depth;
31661     } *params = args;
31662
31663     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->raygenShaderBindingTableBuffer), wine_dbgstr_longlong(params->raygenShaderBindingOffset), wine_dbgstr_longlong(params->missShaderBindingTableBuffer), wine_dbgstr_longlong(params->missShaderBindingOffset), wine_dbgstr_longlong(params->missShaderBindingStride), wine_dbgstr_longlong(params->hitShaderBindingTableBuffer), wine_dbgstr_longlong(params->hitShaderBindingOffset), wine_dbgstr_longlong(params->hitShaderBindingStride), wine_dbgstr_longlong(params->callableShaderBindingTableBuffer), wine_dbgstr_longlong(params->callableShaderBindingOffset), wine_dbgstr_longlong(params->callableShaderBindingStride), params->width, params->height, params->depth);
31664
31665     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->raygenShaderBindingTableBuffer, params->raygenShaderBindingOffset, params->missShaderBindingTableBuffer, params->missShaderBindingOffset, params->missShaderBindingStride, params->hitShaderBindingTableBuffer, params->hitShaderBindingOffset, params->hitShaderBindingStride, params->callableShaderBindingTableBuffer, params->callableShaderBindingOffset, params->callableShaderBindingStride, params->width, params->height, params->depth);
31666     return STATUS_SUCCESS;
31667 }
31668
31669 #endif /* USE_STRUCT_CONVERSION */
31670
31671 #if !defined(USE_STRUCT_CONVERSION)
31672
31673 static NTSTATUS thunk64_vkCmdUpdateBuffer(void *args)
31674 {
31675     struct vkCmdUpdateBuffer_params *params = args;
31676
31677     TRACE("%p, 0x%s, 0x%s, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->dataSize), params->pData);
31678
31679     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdUpdateBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->dstBuffer, params->dstOffset, params->dataSize, params->pData);
31680     return STATUS_SUCCESS;
31681 }
31682
31683 #else /* USE_STRUCT_CONVERSION */
31684
31685 static NTSTATUS thunk32_vkCmdUpdateBuffer(void *args)
31686 {
31687     struct
31688     {
31689         VkCommandBuffer commandBuffer;
31690         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
31691         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
31692         VkDeviceSize DECLSPEC_ALIGN(8) dataSize;
31693         const void *pData;
31694     } *params = args;
31695
31696     TRACE("%p, 0x%s, 0x%s, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->dataSize), params->pData);
31697
31698     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdUpdateBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->dstBuffer, params->dstOffset, params->dataSize, params->pData);
31699     return STATUS_SUCCESS;
31700 }
31701
31702 #endif /* USE_STRUCT_CONVERSION */
31703
31704 #if !defined(USE_STRUCT_CONVERSION)
31705
31706 static NTSTATUS thunk64_vkCmdWaitEvents(void *args)
31707 {
31708     struct vkCmdWaitEvents_params *params = args;
31709
31710     TRACE("%p, %u, %p, %#x, %#x, %u, %p, %u, %p, %u, %p\n", params->commandBuffer, params->eventCount, params->pEvents, params->srcStageMask, params->dstStageMask, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
31711
31712     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWaitEvents(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->eventCount, params->pEvents, params->srcStageMask, params->dstStageMask, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
31713     return STATUS_SUCCESS;
31714 }
31715
31716 #else /* USE_STRUCT_CONVERSION */
31717
31718 static NTSTATUS thunk32_vkCmdWaitEvents(void *args)
31719 {
31720     struct
31721     {
31722         VkCommandBuffer commandBuffer;
31723         uint32_t eventCount;
31724         const VkEvent *pEvents;
31725         VkPipelineStageFlags srcStageMask;
31726         VkPipelineStageFlags dstStageMask;
31727         uint32_t memoryBarrierCount;
31728         const VkMemoryBarrier32 *pMemoryBarriers;
31729         uint32_t bufferMemoryBarrierCount;
31730         const VkBufferMemoryBarrier32 *pBufferMemoryBarriers;
31731         uint32_t imageMemoryBarrierCount;
31732         const VkImageMemoryBarrier32 *pImageMemoryBarriers;
31733     } *params = args;
31734     const VkMemoryBarrier *pMemoryBarriers_host;
31735     const VkBufferMemoryBarrier *pBufferMemoryBarriers_host;
31736     const VkImageMemoryBarrier *pImageMemoryBarriers_host;
31737     struct conversion_context ctx;
31738
31739     TRACE("%p, %u, %p, %#x, %#x, %u, %p, %u, %p, %u, %p\n", params->commandBuffer, params->eventCount, params->pEvents, params->srcStageMask, params->dstStageMask, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
31740
31741     init_conversion_context(&ctx);
31742     pMemoryBarriers_host = convert_VkMemoryBarrier_array_win32_to_host(&ctx, params->pMemoryBarriers, params->memoryBarrierCount);
31743     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win32_to_host(&ctx, params->pBufferMemoryBarriers, params->bufferMemoryBarrierCount);
31744     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win32_to_host(&ctx, params->pImageMemoryBarriers, params->imageMemoryBarrierCount);
31745     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWaitEvents(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->eventCount, params->pEvents, params->srcStageMask, params->dstStageMask, params->memoryBarrierCount, pMemoryBarriers_host, params->bufferMemoryBarrierCount, pBufferMemoryBarriers_host, params->imageMemoryBarrierCount, pImageMemoryBarriers_host);
31746     free_conversion_context(&ctx);
31747     return STATUS_SUCCESS;
31748 }
31749
31750 #endif /* USE_STRUCT_CONVERSION */
31751
31752 #if !defined(USE_STRUCT_CONVERSION)
31753
31754 static NTSTATUS thunk64_vkCmdWaitEvents2(void *args)
31755 {
31756     struct vkCmdWaitEvents2_params *params = args;
31757
31758     TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);
31759
31760     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWaitEvents2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->eventCount, params->pEvents, params->pDependencyInfos);
31761     return STATUS_SUCCESS;
31762 }
31763
31764 #else /* USE_STRUCT_CONVERSION */
31765
31766 static NTSTATUS thunk32_vkCmdWaitEvents2(void *args)
31767 {
31768     struct
31769     {
31770         VkCommandBuffer commandBuffer;
31771         uint32_t eventCount;
31772         const VkEvent *pEvents;
31773         const VkDependencyInfo32 *pDependencyInfos;
31774     } *params = args;
31775     const VkDependencyInfo *pDependencyInfos_host;
31776     struct conversion_context ctx;
31777
31778     TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);
31779
31780     init_conversion_context(&ctx);
31781     pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(&ctx, params->pDependencyInfos, params->eventCount);
31782     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWaitEvents2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->eventCount, params->pEvents, pDependencyInfos_host);
31783     free_conversion_context(&ctx);
31784     return STATUS_SUCCESS;
31785 }
31786
31787 #endif /* USE_STRUCT_CONVERSION */
31788
31789 #if !defined(USE_STRUCT_CONVERSION)
31790
31791 static NTSTATUS thunk64_vkCmdWaitEvents2KHR(void *args)
31792 {
31793     struct vkCmdWaitEvents2KHR_params *params = args;
31794
31795     TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);
31796
31797     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWaitEvents2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->eventCount, params->pEvents, params->pDependencyInfos);
31798     return STATUS_SUCCESS;
31799 }
31800
31801 #else /* USE_STRUCT_CONVERSION */
31802
31803 static NTSTATUS thunk32_vkCmdWaitEvents2KHR(void *args)
31804 {
31805     struct
31806     {
31807         VkCommandBuffer commandBuffer;
31808         uint32_t eventCount;
31809         const VkEvent *pEvents;
31810         const VkDependencyInfo32 *pDependencyInfos;
31811     } *params = args;
31812     const VkDependencyInfo *pDependencyInfos_host;
31813     struct conversion_context ctx;
31814
31815     TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);
31816
31817     init_conversion_context(&ctx);
31818     pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(&ctx, params->pDependencyInfos, params->eventCount);
31819     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWaitEvents2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->eventCount, params->pEvents, pDependencyInfos_host);
31820     free_conversion_context(&ctx);
31821     return STATUS_SUCCESS;
31822 }
31823
31824 #endif /* USE_STRUCT_CONVERSION */
31825
31826 #if !defined(USE_STRUCT_CONVERSION)
31827
31828 static NTSTATUS thunk64_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args)
31829 {
31830     struct vkCmdWriteAccelerationStructuresPropertiesKHR_params *params = args;
31831
31832     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
31833
31834     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, params->queryPool, params->firstQuery);
31835     return STATUS_SUCCESS;
31836 }
31837
31838 #else /* USE_STRUCT_CONVERSION */
31839
31840 static NTSTATUS thunk32_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args)
31841 {
31842     struct
31843     {
31844         VkCommandBuffer commandBuffer;
31845         uint32_t accelerationStructureCount;
31846         const VkAccelerationStructureKHR *pAccelerationStructures;
31847         VkQueryType queryType;
31848         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
31849         uint32_t firstQuery;
31850     } *params = args;
31851
31852     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
31853
31854     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, params->queryPool, params->firstQuery);
31855     return STATUS_SUCCESS;
31856 }
31857
31858 #endif /* USE_STRUCT_CONVERSION */
31859
31860 #if !defined(USE_STRUCT_CONVERSION)
31861
31862 static NTSTATUS thunk64_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
31863 {
31864     struct vkCmdWriteAccelerationStructuresPropertiesNV_params *params = args;
31865
31866     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
31867
31868     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, params->queryPool, params->firstQuery);
31869     return STATUS_SUCCESS;
31870 }
31871
31872 #else /* USE_STRUCT_CONVERSION */
31873
31874 static NTSTATUS thunk32_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
31875 {
31876     struct
31877     {
31878         VkCommandBuffer commandBuffer;
31879         uint32_t accelerationStructureCount;
31880         const VkAccelerationStructureNV *pAccelerationStructures;
31881         VkQueryType queryType;
31882         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
31883         uint32_t firstQuery;
31884     } *params = args;
31885
31886     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
31887
31888     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, params->queryPool, params->firstQuery);
31889     return STATUS_SUCCESS;
31890 }
31891
31892 #endif /* USE_STRUCT_CONVERSION */
31893
31894 #if !defined(USE_STRUCT_CONVERSION)
31895
31896 static NTSTATUS thunk64_vkCmdWriteBufferMarker2AMD(void *args)
31897 {
31898     struct vkCmdWriteBufferMarker2AMD_params *params = args;
31899
31900     TRACE("%p, 0x%s, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), params->marker);
31901
31902     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteBufferMarker2AMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stage, params->dstBuffer, params->dstOffset, params->marker);
31903     return STATUS_SUCCESS;
31904 }
31905
31906 #else /* USE_STRUCT_CONVERSION */
31907
31908 static NTSTATUS thunk32_vkCmdWriteBufferMarker2AMD(void *args)
31909 {
31910     struct
31911     {
31912         VkCommandBuffer commandBuffer;
31913         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
31914         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
31915         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
31916         uint32_t marker;
31917     } *params = args;
31918
31919     TRACE("%p, 0x%s, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), params->marker);
31920
31921     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteBufferMarker2AMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stage, params->dstBuffer, params->dstOffset, params->marker);
31922     return STATUS_SUCCESS;
31923 }
31924
31925 #endif /* USE_STRUCT_CONVERSION */
31926
31927 #if !defined(USE_STRUCT_CONVERSION)
31928
31929 static NTSTATUS thunk64_vkCmdWriteBufferMarkerAMD(void *args)
31930 {
31931     struct vkCmdWriteBufferMarkerAMD_params *params = args;
31932
31933     TRACE("%p, %#x, 0x%s, 0x%s, %u\n", params->commandBuffer, params->pipelineStage, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), params->marker);
31934
31935     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteBufferMarkerAMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStage, params->dstBuffer, params->dstOffset, params->marker);
31936     return STATUS_SUCCESS;
31937 }
31938
31939 #else /* USE_STRUCT_CONVERSION */
31940
31941 static NTSTATUS thunk32_vkCmdWriteBufferMarkerAMD(void *args)
31942 {
31943     struct
31944     {
31945         VkCommandBuffer commandBuffer;
31946         VkPipelineStageFlagBits pipelineStage;
31947         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
31948         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
31949         uint32_t marker;
31950     } *params = args;
31951
31952     TRACE("%p, %#x, 0x%s, 0x%s, %u\n", params->commandBuffer, params->pipelineStage, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), params->marker);
31953
31954     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteBufferMarkerAMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStage, params->dstBuffer, params->dstOffset, params->marker);
31955     return STATUS_SUCCESS;
31956 }
31957
31958 #endif /* USE_STRUCT_CONVERSION */
31959
31960 #if !defined(USE_STRUCT_CONVERSION)
31961
31962 static NTSTATUS thunk64_vkCmdWriteMicromapsPropertiesEXT(void *args)
31963 {
31964     struct vkCmdWriteMicromapsPropertiesEXT_params *params = args;
31965
31966     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->micromapCount, params->pMicromaps, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
31967
31968     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteMicromapsPropertiesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->micromapCount, params->pMicromaps, params->queryType, params->queryPool, params->firstQuery);
31969     return STATUS_SUCCESS;
31970 }
31971
31972 #else /* USE_STRUCT_CONVERSION */
31973
31974 static NTSTATUS thunk32_vkCmdWriteMicromapsPropertiesEXT(void *args)
31975 {
31976     struct
31977     {
31978         VkCommandBuffer commandBuffer;
31979         uint32_t micromapCount;
31980         const VkMicromapEXT *pMicromaps;
31981         VkQueryType queryType;
31982         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
31983         uint32_t firstQuery;
31984     } *params = args;
31985
31986     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->micromapCount, params->pMicromaps, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
31987
31988     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteMicromapsPropertiesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->micromapCount, params->pMicromaps, params->queryType, params->queryPool, params->firstQuery);
31989     return STATUS_SUCCESS;
31990 }
31991
31992 #endif /* USE_STRUCT_CONVERSION */
31993
31994 #if !defined(USE_STRUCT_CONVERSION)
31995
31996 static NTSTATUS thunk64_vkCmdWriteTimestamp(void *args)
31997 {
31998     struct vkCmdWriteTimestamp_params *params = args;
31999
32000     TRACE("%p, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineStage, wine_dbgstr_longlong(params->queryPool), params->query);
32001
32002     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteTimestamp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStage, params->queryPool, params->query);
32003     return STATUS_SUCCESS;
32004 }
32005
32006 #else /* USE_STRUCT_CONVERSION */
32007
32008 static NTSTATUS thunk32_vkCmdWriteTimestamp(void *args)
32009 {
32010     struct
32011     {
32012         VkCommandBuffer commandBuffer;
32013         VkPipelineStageFlagBits pipelineStage;
32014         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
32015         uint32_t query;
32016     } *params = args;
32017
32018     TRACE("%p, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineStage, wine_dbgstr_longlong(params->queryPool), params->query);
32019
32020     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteTimestamp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStage, params->queryPool, params->query);
32021     return STATUS_SUCCESS;
32022 }
32023
32024 #endif /* USE_STRUCT_CONVERSION */
32025
32026 #if !defined(USE_STRUCT_CONVERSION)
32027
32028 static NTSTATUS thunk64_vkCmdWriteTimestamp2(void *args)
32029 {
32030     struct vkCmdWriteTimestamp2_params *params = args;
32031
32032     TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);
32033
32034     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteTimestamp2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stage, params->queryPool, params->query);
32035     return STATUS_SUCCESS;
32036 }
32037
32038 #else /* USE_STRUCT_CONVERSION */
32039
32040 static NTSTATUS thunk32_vkCmdWriteTimestamp2(void *args)
32041 {
32042     struct
32043     {
32044         VkCommandBuffer commandBuffer;
32045         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
32046         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
32047         uint32_t query;
32048     } *params = args;
32049
32050     TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);
32051
32052     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteTimestamp2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stage, params->queryPool, params->query);
32053     return STATUS_SUCCESS;
32054 }
32055
32056 #endif /* USE_STRUCT_CONVERSION */
32057
32058 #if !defined(USE_STRUCT_CONVERSION)
32059
32060 static NTSTATUS thunk64_vkCmdWriteTimestamp2KHR(void *args)
32061 {
32062     struct vkCmdWriteTimestamp2KHR_params *params = args;
32063
32064     TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);
32065
32066     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteTimestamp2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stage, params->queryPool, params->query);
32067     return STATUS_SUCCESS;
32068 }
32069
32070 #else /* USE_STRUCT_CONVERSION */
32071
32072 static NTSTATUS thunk32_vkCmdWriteTimestamp2KHR(void *args)
32073 {
32074     struct
32075     {
32076         VkCommandBuffer commandBuffer;
32077         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
32078         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
32079         uint32_t query;
32080     } *params = args;
32081
32082     TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);
32083
32084     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteTimestamp2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stage, params->queryPool, params->query);
32085     return STATUS_SUCCESS;
32086 }
32087
32088 #endif /* USE_STRUCT_CONVERSION */
32089
32090 #if !defined(USE_STRUCT_CONVERSION)
32091
32092 static NTSTATUS thunk64_vkCompileDeferredNV(void *args)
32093 {
32094     struct vkCompileDeferredNV_params *params = args;
32095
32096     TRACE("%p, 0x%s, %u\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shader);
32097
32098     params->result = wine_device_from_handle(params->device)->funcs.p_vkCompileDeferredNV(wine_device_from_handle(params->device)->device, params->pipeline, params->shader);
32099     return STATUS_SUCCESS;
32100 }
32101
32102 #else /* USE_STRUCT_CONVERSION */
32103
32104 static NTSTATUS thunk32_vkCompileDeferredNV(void *args)
32105 {
32106     struct
32107     {
32108         VkDevice device;
32109         VkPipeline DECLSPEC_ALIGN(8) pipeline;
32110         uint32_t shader;
32111         VkResult result;
32112     } *params = args;
32113
32114     TRACE("%p, 0x%s, %u\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shader);
32115
32116     params->result = wine_device_from_handle(params->device)->funcs.p_vkCompileDeferredNV(wine_device_from_handle(params->device)->device, params->pipeline, params->shader);
32117     return STATUS_SUCCESS;
32118 }
32119
32120 #endif /* USE_STRUCT_CONVERSION */
32121
32122 #if !defined(USE_STRUCT_CONVERSION)
32123
32124 static NTSTATUS thunk64_vkCopyAccelerationStructureKHR(void *args)
32125 {
32126     struct vkCopyAccelerationStructureKHR_params *params = args;
32127
32128     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32129
32130     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
32131     return STATUS_SUCCESS;
32132 }
32133
32134 #else /* USE_STRUCT_CONVERSION */
32135
32136 static NTSTATUS thunk32_vkCopyAccelerationStructureKHR(void *args)
32137 {
32138     struct
32139     {
32140         VkDevice device;
32141         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
32142         const VkCopyAccelerationStructureInfoKHR32 *pInfo;
32143         VkResult result;
32144     } *params = args;
32145     VkCopyAccelerationStructureInfoKHR pInfo_host;
32146
32147     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32148
32149     convert_VkCopyAccelerationStructureInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
32150     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
32151     return STATUS_SUCCESS;
32152 }
32153
32154 #endif /* USE_STRUCT_CONVERSION */
32155
32156 #if !defined(USE_STRUCT_CONVERSION)
32157
32158 static NTSTATUS thunk64_vkCopyAccelerationStructureToMemoryKHR(void *args)
32159 {
32160     struct vkCopyAccelerationStructureToMemoryKHR_params *params = args;
32161
32162     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32163
32164     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureToMemoryKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
32165     return STATUS_SUCCESS;
32166 }
32167
32168 #else /* USE_STRUCT_CONVERSION */
32169
32170 static NTSTATUS thunk32_vkCopyAccelerationStructureToMemoryKHR(void *args)
32171 {
32172     struct
32173     {
32174         VkDevice device;
32175         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
32176         const VkCopyAccelerationStructureToMemoryInfoKHR32 *pInfo;
32177         VkResult result;
32178     } *params = args;
32179     VkCopyAccelerationStructureToMemoryInfoKHR pInfo_host;
32180
32181     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32182
32183     convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
32184     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureToMemoryKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
32185     return STATUS_SUCCESS;
32186 }
32187
32188 #endif /* USE_STRUCT_CONVERSION */
32189
32190 #if !defined(USE_STRUCT_CONVERSION)
32191
32192 static NTSTATUS thunk64_vkCopyMemoryToAccelerationStructureKHR(void *args)
32193 {
32194     struct vkCopyMemoryToAccelerationStructureKHR_params *params = args;
32195
32196     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32197
32198     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
32199     return STATUS_SUCCESS;
32200 }
32201
32202 #else /* USE_STRUCT_CONVERSION */
32203
32204 static NTSTATUS thunk32_vkCopyMemoryToAccelerationStructureKHR(void *args)
32205 {
32206     struct
32207     {
32208         VkDevice device;
32209         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
32210         const VkCopyMemoryToAccelerationStructureInfoKHR32 *pInfo;
32211         VkResult result;
32212     } *params = args;
32213     VkCopyMemoryToAccelerationStructureInfoKHR pInfo_host;
32214
32215     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32216
32217     convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
32218     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
32219     return STATUS_SUCCESS;
32220 }
32221
32222 #endif /* USE_STRUCT_CONVERSION */
32223
32224 #if !defined(USE_STRUCT_CONVERSION)
32225
32226 static NTSTATUS thunk64_vkCopyMemoryToMicromapEXT(void *args)
32227 {
32228     struct vkCopyMemoryToMicromapEXT_params *params = args;
32229
32230     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32231
32232     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
32233     return STATUS_SUCCESS;
32234 }
32235
32236 #else /* USE_STRUCT_CONVERSION */
32237
32238 static NTSTATUS thunk32_vkCopyMemoryToMicromapEXT(void *args)
32239 {
32240     struct
32241     {
32242         VkDevice device;
32243         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
32244         const VkCopyMemoryToMicromapInfoEXT32 *pInfo;
32245         VkResult result;
32246     } *params = args;
32247     VkCopyMemoryToMicromapInfoEXT pInfo_host;
32248
32249     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32250
32251     convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
32252     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
32253     return STATUS_SUCCESS;
32254 }
32255
32256 #endif /* USE_STRUCT_CONVERSION */
32257
32258 #if !defined(USE_STRUCT_CONVERSION)
32259
32260 static NTSTATUS thunk64_vkCopyMicromapEXT(void *args)
32261 {
32262     struct vkCopyMicromapEXT_params *params = args;
32263
32264     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32265
32266     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
32267     return STATUS_SUCCESS;
32268 }
32269
32270 #else /* USE_STRUCT_CONVERSION */
32271
32272 static NTSTATUS thunk32_vkCopyMicromapEXT(void *args)
32273 {
32274     struct
32275     {
32276         VkDevice device;
32277         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
32278         const VkCopyMicromapInfoEXT32 *pInfo;
32279         VkResult result;
32280     } *params = args;
32281     VkCopyMicromapInfoEXT pInfo_host;
32282
32283     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32284
32285     convert_VkCopyMicromapInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
32286     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
32287     return STATUS_SUCCESS;
32288 }
32289
32290 #endif /* USE_STRUCT_CONVERSION */
32291
32292 #if !defined(USE_STRUCT_CONVERSION)
32293
32294 static NTSTATUS thunk64_vkCopyMicromapToMemoryEXT(void *args)
32295 {
32296     struct vkCopyMicromapToMemoryEXT_params *params = args;
32297
32298     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32299
32300     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapToMemoryEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
32301     return STATUS_SUCCESS;
32302 }
32303
32304 #else /* USE_STRUCT_CONVERSION */
32305
32306 static NTSTATUS thunk32_vkCopyMicromapToMemoryEXT(void *args)
32307 {
32308     struct
32309     {
32310         VkDevice device;
32311         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
32312         const VkCopyMicromapToMemoryInfoEXT32 *pInfo;
32313         VkResult result;
32314     } *params = args;
32315     VkCopyMicromapToMemoryInfoEXT pInfo_host;
32316
32317     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32318
32319     convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
32320     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapToMemoryEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
32321     return STATUS_SUCCESS;
32322 }
32323
32324 #endif /* USE_STRUCT_CONVERSION */
32325
32326 #if !defined(USE_STRUCT_CONVERSION)
32327
32328 static NTSTATUS thunk64_vkCreateAccelerationStructureKHR(void *args)
32329 {
32330     struct vkCreateAccelerationStructureKHR_params *params = args;
32331
32332     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
32333
32334     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pAccelerationStructure);
32335     return STATUS_SUCCESS;
32336 }
32337
32338 #else /* USE_STRUCT_CONVERSION */
32339
32340 static NTSTATUS thunk32_vkCreateAccelerationStructureKHR(void *args)
32341 {
32342     struct
32343     {
32344         VkDevice device;
32345         const VkAccelerationStructureCreateInfoKHR32 *pCreateInfo;
32346         const VkAllocationCallbacks *pAllocator;
32347         VkAccelerationStructureKHR *pAccelerationStructure;
32348         VkResult result;
32349     } *params = args;
32350     VkAccelerationStructureCreateInfoKHR pCreateInfo_host;
32351     struct conversion_context ctx;
32352
32353     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
32354
32355     init_conversion_context(&ctx);
32356     convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
32357     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pAccelerationStructure);
32358     free_conversion_context(&ctx);
32359     return STATUS_SUCCESS;
32360 }
32361
32362 #endif /* USE_STRUCT_CONVERSION */
32363
32364 #if !defined(USE_STRUCT_CONVERSION)
32365
32366 static NTSTATUS thunk64_vkCreateAccelerationStructureNV(void *args)
32367 {
32368     struct vkCreateAccelerationStructureNV_params *params = args;
32369
32370     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
32371
32372     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pAccelerationStructure);
32373     return STATUS_SUCCESS;
32374 }
32375
32376 #else /* USE_STRUCT_CONVERSION */
32377
32378 static NTSTATUS thunk32_vkCreateAccelerationStructureNV(void *args)
32379 {
32380     struct
32381     {
32382         VkDevice device;
32383         const VkAccelerationStructureCreateInfoNV32 *pCreateInfo;
32384         const VkAllocationCallbacks *pAllocator;
32385         VkAccelerationStructureNV *pAccelerationStructure;
32386         VkResult result;
32387     } *params = args;
32388     VkAccelerationStructureCreateInfoNV pCreateInfo_host;
32389     struct conversion_context ctx;
32390
32391     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
32392
32393     init_conversion_context(&ctx);
32394     convert_VkAccelerationStructureCreateInfoNV_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
32395     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureNV(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pAccelerationStructure);
32396     free_conversion_context(&ctx);
32397     return STATUS_SUCCESS;
32398 }
32399
32400 #endif /* USE_STRUCT_CONVERSION */
32401
32402 #if !defined(USE_STRUCT_CONVERSION)
32403
32404 static NTSTATUS thunk64_vkCreateBuffer(void *args)
32405 {
32406     struct vkCreateBuffer_params *params = args;
32407
32408     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pBuffer);
32409
32410     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateBuffer(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pBuffer);
32411     return STATUS_SUCCESS;
32412 }
32413
32414 #else /* USE_STRUCT_CONVERSION */
32415
32416 static NTSTATUS thunk32_vkCreateBuffer(void *args)
32417 {
32418     struct
32419     {
32420         VkDevice device;
32421         const VkBufferCreateInfo32 *pCreateInfo;
32422         const VkAllocationCallbacks *pAllocator;
32423         VkBuffer *pBuffer;
32424         VkResult result;
32425     } *params = args;
32426     VkBufferCreateInfo pCreateInfo_host;
32427     struct conversion_context ctx;
32428
32429     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pBuffer);
32430
32431     init_conversion_context(&ctx);
32432     convert_VkBufferCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
32433     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateBuffer(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pBuffer);
32434     free_conversion_context(&ctx);
32435     return STATUS_SUCCESS;
32436 }
32437
32438 #endif /* USE_STRUCT_CONVERSION */
32439
32440 #if !defined(USE_STRUCT_CONVERSION)
32441
32442 static NTSTATUS thunk64_vkCreateBufferView(void *args)
32443 {
32444     struct vkCreateBufferView_params *params = args;
32445
32446     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
32447
32448     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateBufferView(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pView);
32449     return STATUS_SUCCESS;
32450 }
32451
32452 #else /* USE_STRUCT_CONVERSION */
32453
32454 static NTSTATUS thunk32_vkCreateBufferView(void *args)
32455 {
32456     struct
32457     {
32458         VkDevice device;
32459         const VkBufferViewCreateInfo32 *pCreateInfo;
32460         const VkAllocationCallbacks *pAllocator;
32461         VkBufferView *pView;
32462         VkResult result;
32463     } *params = args;
32464     VkBufferViewCreateInfo pCreateInfo_host;
32465
32466     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
32467
32468     convert_VkBufferViewCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
32469     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateBufferView(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pView);
32470     return STATUS_SUCCESS;
32471 }
32472
32473 #endif /* USE_STRUCT_CONVERSION */
32474
32475 #if !defined(USE_STRUCT_CONVERSION)
32476
32477 static NTSTATUS thunk64_vkCreateCommandPool(void *args)
32478 {
32479     struct vkCreateCommandPool_params *params = args;
32480
32481     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool);
32482
32483     params->result = wine_vkCreateCommandPool(params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool, params->client_ptr);
32484     return STATUS_SUCCESS;
32485 }
32486
32487 #else /* USE_STRUCT_CONVERSION */
32488
32489 static NTSTATUS thunk32_vkCreateCommandPool(void *args)
32490 {
32491     struct
32492     {
32493         VkDevice device;
32494         const VkCommandPoolCreateInfo32 *pCreateInfo;
32495         const VkAllocationCallbacks *pAllocator;
32496         VkCommandPool *pCommandPool;
32497         void *client_ptr;
32498         VkResult result;
32499     } *params = args;
32500     VkCommandPoolCreateInfo pCreateInfo_host;
32501
32502     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool);
32503
32504     convert_VkCommandPoolCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
32505     params->result = wine_vkCreateCommandPool(params->device, &pCreateInfo_host, params->pAllocator, params->pCommandPool, params->client_ptr);
32506     return STATUS_SUCCESS;
32507 }
32508
32509 #endif /* USE_STRUCT_CONVERSION */
32510
32511 #if !defined(USE_STRUCT_CONVERSION)
32512
32513 static NTSTATUS thunk64_vkCreateComputePipelines(void *args)
32514 {
32515     struct vkCreateComputePipelines_params *params = args;
32516     const VkComputePipelineCreateInfo *pCreateInfos_host;
32517     struct conversion_context ctx;
32518
32519     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
32520
32521     init_conversion_context(&ctx);
32522     pCreateInfos_host = convert_VkComputePipelineCreateInfo_array_win64_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
32523     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateComputePipelines(wine_device_from_handle(params->device)->device, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, params->pPipelines);
32524     free_conversion_context(&ctx);
32525     return STATUS_SUCCESS;
32526 }
32527
32528 #else /* USE_STRUCT_CONVERSION */
32529
32530 static NTSTATUS thunk32_vkCreateComputePipelines(void *args)
32531 {
32532     struct
32533     {
32534         VkDevice device;
32535         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
32536         uint32_t createInfoCount;
32537         const VkComputePipelineCreateInfo32 *pCreateInfos;
32538         const VkAllocationCallbacks *pAllocator;
32539         VkPipeline *pPipelines;
32540         VkResult result;
32541     } *params = args;
32542     const VkComputePipelineCreateInfo *pCreateInfos_host;
32543     struct conversion_context ctx;
32544
32545     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
32546
32547     init_conversion_context(&ctx);
32548     pCreateInfos_host = convert_VkComputePipelineCreateInfo_array_win32_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
32549     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateComputePipelines(wine_device_from_handle(params->device)->device, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, params->pPipelines);
32550     convert_VkComputePipelineCreateInfo_array_host_to_win32(pCreateInfos_host, params->pCreateInfos, params->createInfoCount);
32551     free_conversion_context(&ctx);
32552     return STATUS_SUCCESS;
32553 }
32554
32555 #endif /* USE_STRUCT_CONVERSION */
32556
32557 #if !defined(USE_STRUCT_CONVERSION)
32558
32559 static NTSTATUS thunk64_vkCreateCuFunctionNVX(void *args)
32560 {
32561     struct vkCreateCuFunctionNVX_params *params = args;
32562
32563     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFunction);
32564
32565     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuFunctionNVX(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFunction);
32566     return STATUS_SUCCESS;
32567 }
32568
32569 #else /* USE_STRUCT_CONVERSION */
32570
32571 static NTSTATUS thunk32_vkCreateCuFunctionNVX(void *args)
32572 {
32573     struct
32574     {
32575         VkDevice device;
32576         const VkCuFunctionCreateInfoNVX32 *pCreateInfo;
32577         const VkAllocationCallbacks *pAllocator;
32578         VkCuFunctionNVX *pFunction;
32579         VkResult result;
32580     } *params = args;
32581     VkCuFunctionCreateInfoNVX pCreateInfo_host;
32582
32583     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFunction);
32584
32585     convert_VkCuFunctionCreateInfoNVX_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
32586     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuFunctionNVX(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pFunction);
32587     return STATUS_SUCCESS;
32588 }
32589
32590 #endif /* USE_STRUCT_CONVERSION */
32591
32592 #if !defined(USE_STRUCT_CONVERSION)
32593
32594 static NTSTATUS thunk64_vkCreateCuModuleNVX(void *args)
32595 {
32596     struct vkCreateCuModuleNVX_params *params = args;
32597
32598     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pModule);
32599
32600     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuModuleNVX(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pModule);
32601     return STATUS_SUCCESS;
32602 }
32603
32604 #else /* USE_STRUCT_CONVERSION */
32605
32606 static NTSTATUS thunk32_vkCreateCuModuleNVX(void *args)
32607 {
32608     struct
32609     {
32610         VkDevice device;
32611         const VkCuModuleCreateInfoNVX32 *pCreateInfo;
32612         const VkAllocationCallbacks *pAllocator;
32613         VkCuModuleNVX *pModule;
32614         VkResult result;
32615     } *params = args;
32616     VkCuModuleCreateInfoNVX pCreateInfo_host;
32617
32618     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pModule);
32619
32620     convert_VkCuModuleCreateInfoNVX_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
32621     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuModuleNVX(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pModule);
32622     return STATUS_SUCCESS;
32623 }
32624
32625 #endif /* USE_STRUCT_CONVERSION */
32626
32627 #if !defined(USE_STRUCT_CONVERSION)
32628
32629 static NTSTATUS thunk64_vkCreateDebugReportCallbackEXT(void *args)
32630 {
32631     struct vkCreateDebugReportCallbackEXT_params *params = args;
32632
32633     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
32634
32635     params->result = wine_vkCreateDebugReportCallbackEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
32636     return STATUS_SUCCESS;
32637 }
32638
32639 #else /* USE_STRUCT_CONVERSION */
32640
32641 static NTSTATUS thunk32_vkCreateDebugReportCallbackEXT(void *args)
32642 {
32643     struct
32644     {
32645         VkInstance instance;
32646         const VkDebugReportCallbackCreateInfoEXT32 *pCreateInfo;
32647         const VkAllocationCallbacks *pAllocator;
32648         VkDebugReportCallbackEXT *pCallback;
32649         VkResult result;
32650     } *params = args;
32651     VkDebugReportCallbackCreateInfoEXT pCreateInfo_host;
32652
32653     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
32654
32655     convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
32656     params->result = wine_vkCreateDebugReportCallbackEXT(params->instance, &pCreateInfo_host, params->pAllocator, params->pCallback);
32657     return STATUS_SUCCESS;
32658 }
32659
32660 #endif /* USE_STRUCT_CONVERSION */
32661
32662 #if !defined(USE_STRUCT_CONVERSION)
32663
32664 static NTSTATUS thunk64_vkCreateDebugUtilsMessengerEXT(void *args)
32665 {
32666     struct vkCreateDebugUtilsMessengerEXT_params *params = args;
32667
32668     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
32669
32670     params->result = wine_vkCreateDebugUtilsMessengerEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
32671     return STATUS_SUCCESS;
32672 }
32673
32674 #else /* USE_STRUCT_CONVERSION */
32675
32676 static NTSTATUS thunk32_vkCreateDebugUtilsMessengerEXT(void *args)
32677 {
32678     struct
32679     {
32680         VkInstance instance;
32681         const VkDebugUtilsMessengerCreateInfoEXT32 *pCreateInfo;
32682         const VkAllocationCallbacks *pAllocator;
32683         VkDebugUtilsMessengerEXT *pMessenger;
32684         VkResult result;
32685     } *params = args;
32686     VkDebugUtilsMessengerCreateInfoEXT pCreateInfo_host;
32687
32688     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
32689
32690     convert_VkDebugUtilsMessengerCreateInfoEXT_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
32691     params->result = wine_vkCreateDebugUtilsMessengerEXT(params->instance, &pCreateInfo_host, params->pAllocator, params->pMessenger);
32692     return STATUS_SUCCESS;
32693 }
32694
32695 #endif /* USE_STRUCT_CONVERSION */
32696
32697 #if !defined(USE_STRUCT_CONVERSION)
32698
32699 static NTSTATUS thunk64_vkCreateDeferredOperationKHR(void *args)
32700 {
32701     struct vkCreateDeferredOperationKHR_params *params = args;
32702
32703     TRACE("%p, %p, %p\n", params->device, params->pAllocator, params->pDeferredOperation);
32704
32705     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDeferredOperationKHR(wine_device_from_handle(params->device)->device, NULL, params->pDeferredOperation);
32706     return STATUS_SUCCESS;
32707 }
32708
32709 #else /* USE_STRUCT_CONVERSION */
32710
32711 static NTSTATUS thunk32_vkCreateDeferredOperationKHR(void *args)
32712 {
32713     struct
32714     {
32715         VkDevice device;
32716         const VkAllocationCallbacks *pAllocator;
32717         VkDeferredOperationKHR *pDeferredOperation;
32718         VkResult result;
32719     } *params = args;
32720
32721     TRACE("%p, %p, %p\n", params->device, params->pAllocator, params->pDeferredOperation);
32722
32723     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDeferredOperationKHR(wine_device_from_handle(params->device)->device, NULL, params->pDeferredOperation);
32724     return STATUS_SUCCESS;
32725 }
32726
32727 #endif /* USE_STRUCT_CONVERSION */
32728
32729 #if !defined(USE_STRUCT_CONVERSION)
32730
32731 static NTSTATUS thunk64_vkCreateDescriptorPool(void *args)
32732 {
32733     struct vkCreateDescriptorPool_params *params = args;
32734
32735     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorPool);
32736
32737     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorPool);
32738     return STATUS_SUCCESS;
32739 }
32740
32741 #else /* USE_STRUCT_CONVERSION */
32742
32743 static NTSTATUS thunk32_vkCreateDescriptorPool(void *args)
32744 {
32745     struct
32746     {
32747         VkDevice device;
32748         const VkDescriptorPoolCreateInfo32 *pCreateInfo;
32749         const VkAllocationCallbacks *pAllocator;
32750         VkDescriptorPool *pDescriptorPool;
32751         VkResult result;
32752     } *params = args;
32753     VkDescriptorPoolCreateInfo pCreateInfo_host;
32754     struct conversion_context ctx;
32755
32756     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorPool);
32757
32758     init_conversion_context(&ctx);
32759     convert_VkDescriptorPoolCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
32760     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorPool(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pDescriptorPool);
32761     free_conversion_context(&ctx);
32762     return STATUS_SUCCESS;
32763 }
32764
32765 #endif /* USE_STRUCT_CONVERSION */
32766
32767 #if !defined(USE_STRUCT_CONVERSION)
32768
32769 static NTSTATUS thunk64_vkCreateDescriptorSetLayout(void *args)
32770 {
32771     struct vkCreateDescriptorSetLayout_params *params = args;
32772
32773     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSetLayout);
32774
32775     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSetLayout);
32776     return STATUS_SUCCESS;
32777 }
32778
32779 #else /* USE_STRUCT_CONVERSION */
32780
32781 static NTSTATUS thunk32_vkCreateDescriptorSetLayout(void *args)
32782 {
32783     struct
32784     {
32785         VkDevice device;
32786         const VkDescriptorSetLayoutCreateInfo32 *pCreateInfo;
32787         const VkAllocationCallbacks *pAllocator;
32788         VkDescriptorSetLayout *pSetLayout;
32789         VkResult result;
32790     } *params = args;
32791     VkDescriptorSetLayoutCreateInfo pCreateInfo_host;
32792     struct conversion_context ctx;
32793
32794     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSetLayout);
32795
32796     init_conversion_context(&ctx);
32797     convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
32798     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorSetLayout(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSetLayout);
32799     free_conversion_context(&ctx);
32800     return STATUS_SUCCESS;
32801 }
32802
32803 #endif /* USE_STRUCT_CONVERSION */
32804
32805 #if !defined(USE_STRUCT_CONVERSION)
32806
32807 static NTSTATUS thunk64_vkCreateDescriptorUpdateTemplate(void *args)
32808 {
32809     struct vkCreateDescriptorUpdateTemplate_params *params = args;
32810
32811     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
32812
32813     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorUpdateTemplate);
32814     return STATUS_SUCCESS;
32815 }
32816
32817 #else /* USE_STRUCT_CONVERSION */
32818
32819 static NTSTATUS thunk32_vkCreateDescriptorUpdateTemplate(void *args)
32820 {
32821     struct
32822     {
32823         VkDevice device;
32824         const VkDescriptorUpdateTemplateCreateInfo32 *pCreateInfo;
32825         const VkAllocationCallbacks *pAllocator;
32826         VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate;
32827         VkResult result;
32828     } *params = args;
32829     VkDescriptorUpdateTemplateCreateInfo pCreateInfo_host;
32830
32831     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
32832
32833     convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
32834     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pDescriptorUpdateTemplate);
32835     return STATUS_SUCCESS;
32836 }
32837
32838 #endif /* USE_STRUCT_CONVERSION */
32839
32840 #if !defined(USE_STRUCT_CONVERSION)
32841
32842 static NTSTATUS thunk64_vkCreateDescriptorUpdateTemplateKHR(void *args)
32843 {
32844     struct vkCreateDescriptorUpdateTemplateKHR_params *params = args;
32845
32846     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
32847
32848     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorUpdateTemplate);
32849     return STATUS_SUCCESS;
32850 }
32851
32852 #else /* USE_STRUCT_CONVERSION */
32853
32854 static NTSTATUS thunk32_vkCreateDescriptorUpdateTemplateKHR(void *args)
32855 {
32856     struct
32857     {
32858         VkDevice device;
32859         const VkDescriptorUpdateTemplateCreateInfo32 *pCreateInfo;
32860         const VkAllocationCallbacks *pAllocator;
32861         VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate;
32862         VkResult result;
32863     } *params = args;
32864     VkDescriptorUpdateTemplateCreateInfo pCreateInfo_host;
32865
32866     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
32867
32868     convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
32869     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pDescriptorUpdateTemplate);
32870     return STATUS_SUCCESS;
32871 }
32872
32873 #endif /* USE_STRUCT_CONVERSION */
32874
32875 #if !defined(USE_STRUCT_CONVERSION)
32876
32877 static NTSTATUS thunk64_vkCreateDevice(void *args)
32878 {
32879     struct vkCreateDevice_params *params = args;
32880     VkDeviceCreateInfo pCreateInfo_host;
32881     struct conversion_context ctx;
32882
32883     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice);
32884
32885     init_conversion_context(&ctx);
32886     convert_VkDeviceCreateInfo_win64_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
32887     params->result = wine_vkCreateDevice(params->physicalDevice, &pCreateInfo_host, params->pAllocator, params->pDevice, params->client_ptr);
32888     free_conversion_context(&ctx);
32889     return STATUS_SUCCESS;
32890 }
32891
32892 #else /* USE_STRUCT_CONVERSION */
32893
32894 static NTSTATUS thunk32_vkCreateDevice(void *args)
32895 {
32896     struct
32897     {
32898         VkPhysicalDevice physicalDevice;
32899         const VkDeviceCreateInfo32 *pCreateInfo;
32900         const VkAllocationCallbacks *pAllocator;
32901         VkDevice *pDevice;
32902         void *client_ptr;
32903         VkResult result;
32904     } *params = args;
32905     VkDeviceCreateInfo pCreateInfo_host;
32906     struct conversion_context ctx;
32907
32908     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice);
32909
32910     init_conversion_context(&ctx);
32911     convert_VkDeviceCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
32912     params->result = wine_vkCreateDevice(params->physicalDevice, &pCreateInfo_host, params->pAllocator, params->pDevice, params->client_ptr);
32913     free_conversion_context(&ctx);
32914     return STATUS_SUCCESS;
32915 }
32916
32917 #endif /* USE_STRUCT_CONVERSION */
32918
32919 #if !defined(USE_STRUCT_CONVERSION)
32920
32921 static NTSTATUS thunk64_vkCreateEvent(void *args)
32922 {
32923     struct vkCreateEvent_params *params = args;
32924
32925     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pEvent);
32926
32927     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateEvent(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pEvent);
32928     return STATUS_SUCCESS;
32929 }
32930
32931 #else /* USE_STRUCT_CONVERSION */
32932
32933 static NTSTATUS thunk32_vkCreateEvent(void *args)
32934 {
32935     struct
32936     {
32937         VkDevice device;
32938         const VkEventCreateInfo32 *pCreateInfo;
32939         const VkAllocationCallbacks *pAllocator;
32940         VkEvent *pEvent;
32941         VkResult result;
32942     } *params = args;
32943     VkEventCreateInfo pCreateInfo_host;
32944
32945     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pEvent);
32946
32947     convert_VkEventCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
32948     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateEvent(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pEvent);
32949     return STATUS_SUCCESS;
32950 }
32951
32952 #endif /* USE_STRUCT_CONVERSION */
32953
32954 #if !defined(USE_STRUCT_CONVERSION)
32955
32956 static NTSTATUS thunk64_vkCreateFence(void *args)
32957 {
32958     struct vkCreateFence_params *params = args;
32959
32960     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFence);
32961
32962     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFence(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFence);
32963     return STATUS_SUCCESS;
32964 }
32965
32966 #else /* USE_STRUCT_CONVERSION */
32967
32968 static NTSTATUS thunk32_vkCreateFence(void *args)
32969 {
32970     struct
32971     {
32972         VkDevice device;
32973         const VkFenceCreateInfo32 *pCreateInfo;
32974         const VkAllocationCallbacks *pAllocator;
32975         VkFence *pFence;
32976         VkResult result;
32977     } *params = args;
32978     VkFenceCreateInfo pCreateInfo_host;
32979     struct conversion_context ctx;
32980
32981     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFence);
32982
32983     init_conversion_context(&ctx);
32984     convert_VkFenceCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
32985     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFence(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pFence);
32986     free_conversion_context(&ctx);
32987     return STATUS_SUCCESS;
32988 }
32989
32990 #endif /* USE_STRUCT_CONVERSION */
32991
32992 #if !defined(USE_STRUCT_CONVERSION)
32993
32994 static NTSTATUS thunk64_vkCreateFramebuffer(void *args)
32995 {
32996     struct vkCreateFramebuffer_params *params = args;
32997
32998     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFramebuffer);
32999
33000     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFramebuffer(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFramebuffer);
33001     return STATUS_SUCCESS;
33002 }
33003
33004 #else /* USE_STRUCT_CONVERSION */
33005
33006 static NTSTATUS thunk32_vkCreateFramebuffer(void *args)
33007 {
33008     struct
33009     {
33010         VkDevice device;
33011         const VkFramebufferCreateInfo32 *pCreateInfo;
33012         const VkAllocationCallbacks *pAllocator;
33013         VkFramebuffer *pFramebuffer;
33014         VkResult result;
33015     } *params = args;
33016     VkFramebufferCreateInfo pCreateInfo_host;
33017     struct conversion_context ctx;
33018
33019     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFramebuffer);
33020
33021     init_conversion_context(&ctx);
33022     convert_VkFramebufferCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
33023     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFramebuffer(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pFramebuffer);
33024     free_conversion_context(&ctx);
33025     return STATUS_SUCCESS;
33026 }
33027
33028 #endif /* USE_STRUCT_CONVERSION */
33029
33030 #if !defined(USE_STRUCT_CONVERSION)
33031
33032 static NTSTATUS thunk64_vkCreateGraphicsPipelines(void *args)
33033 {
33034     struct vkCreateGraphicsPipelines_params *params = args;
33035     const VkGraphicsPipelineCreateInfo *pCreateInfos_host;
33036     struct conversion_context ctx;
33037
33038     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
33039
33040     init_conversion_context(&ctx);
33041     pCreateInfos_host = convert_VkGraphicsPipelineCreateInfo_array_win64_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
33042     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateGraphicsPipelines(wine_device_from_handle(params->device)->device, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, params->pPipelines);
33043     free_conversion_context(&ctx);
33044     return STATUS_SUCCESS;
33045 }
33046
33047 #else /* USE_STRUCT_CONVERSION */
33048
33049 static NTSTATUS thunk32_vkCreateGraphicsPipelines(void *args)
33050 {
33051     struct
33052     {
33053         VkDevice device;
33054         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
33055         uint32_t createInfoCount;
33056         const VkGraphicsPipelineCreateInfo32 *pCreateInfos;
33057         const VkAllocationCallbacks *pAllocator;
33058         VkPipeline *pPipelines;
33059         VkResult result;
33060     } *params = args;
33061     const VkGraphicsPipelineCreateInfo *pCreateInfos_host;
33062     struct conversion_context ctx;
33063
33064     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
33065
33066     init_conversion_context(&ctx);
33067     pCreateInfos_host = convert_VkGraphicsPipelineCreateInfo_array_win32_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
33068     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateGraphicsPipelines(wine_device_from_handle(params->device)->device, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, params->pPipelines);
33069     convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(pCreateInfos_host, params->pCreateInfos, params->createInfoCount);
33070     free_conversion_context(&ctx);
33071     return STATUS_SUCCESS;
33072 }
33073
33074 #endif /* USE_STRUCT_CONVERSION */
33075
33076 #if !defined(USE_STRUCT_CONVERSION)
33077
33078 static NTSTATUS thunk64_vkCreateImage(void *args)
33079 {
33080     struct vkCreateImage_params *params = args;
33081
33082     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pImage);
33083
33084     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateImage(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pImage);
33085     return STATUS_SUCCESS;
33086 }
33087
33088 #else /* USE_STRUCT_CONVERSION */
33089
33090 static NTSTATUS thunk32_vkCreateImage(void *args)
33091 {
33092     struct
33093     {
33094         VkDevice device;
33095         const VkImageCreateInfo32 *pCreateInfo;
33096         const VkAllocationCallbacks *pAllocator;
33097         VkImage *pImage;
33098         VkResult result;
33099     } *params = args;
33100     VkImageCreateInfo pCreateInfo_host;
33101     struct conversion_context ctx;
33102
33103     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pImage);
33104
33105     init_conversion_context(&ctx);
33106     convert_VkImageCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
33107     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateImage(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pImage);
33108     free_conversion_context(&ctx);
33109     return STATUS_SUCCESS;
33110 }
33111
33112 #endif /* USE_STRUCT_CONVERSION */
33113
33114 #if !defined(USE_STRUCT_CONVERSION)
33115
33116 static NTSTATUS thunk64_vkCreateImageView(void *args)
33117 {
33118     struct vkCreateImageView_params *params = args;
33119
33120     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
33121
33122     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateImageView(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pView);
33123     return STATUS_SUCCESS;
33124 }
33125
33126 #else /* USE_STRUCT_CONVERSION */
33127
33128 static NTSTATUS thunk32_vkCreateImageView(void *args)
33129 {
33130     struct
33131     {
33132         VkDevice device;
33133         const VkImageViewCreateInfo32 *pCreateInfo;
33134         const VkAllocationCallbacks *pAllocator;
33135         VkImageView *pView;
33136         VkResult result;
33137     } *params = args;
33138     VkImageViewCreateInfo pCreateInfo_host;
33139     struct conversion_context ctx;
33140
33141     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
33142
33143     init_conversion_context(&ctx);
33144     convert_VkImageViewCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
33145     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateImageView(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pView);
33146     free_conversion_context(&ctx);
33147     return STATUS_SUCCESS;
33148 }
33149
33150 #endif /* USE_STRUCT_CONVERSION */
33151
33152 #if !defined(USE_STRUCT_CONVERSION)
33153
33154 static NTSTATUS thunk64_vkCreateIndirectCommandsLayoutNV(void *args)
33155 {
33156     struct vkCreateIndirectCommandsLayoutNV_params *params = args;
33157
33158     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout);
33159
33160     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pIndirectCommandsLayout);
33161     return STATUS_SUCCESS;
33162 }
33163
33164 #else /* USE_STRUCT_CONVERSION */
33165
33166 static NTSTATUS thunk32_vkCreateIndirectCommandsLayoutNV(void *args)
33167 {
33168     struct
33169     {
33170         VkDevice device;
33171         const VkIndirectCommandsLayoutCreateInfoNV32 *pCreateInfo;
33172         const VkAllocationCallbacks *pAllocator;
33173         VkIndirectCommandsLayoutNV *pIndirectCommandsLayout;
33174         VkResult result;
33175     } *params = args;
33176     VkIndirectCommandsLayoutCreateInfoNV pCreateInfo_host;
33177     struct conversion_context ctx;
33178
33179     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout);
33180
33181     init_conversion_context(&ctx);
33182     convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
33183     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pIndirectCommandsLayout);
33184     free_conversion_context(&ctx);
33185     return STATUS_SUCCESS;
33186 }
33187
33188 #endif /* USE_STRUCT_CONVERSION */
33189
33190 #if !defined(USE_STRUCT_CONVERSION)
33191
33192 static NTSTATUS thunk64_vkCreateInstance(void *args)
33193 {
33194     struct vkCreateInstance_params *params = args;
33195     VkInstanceCreateInfo pCreateInfo_host;
33196     struct conversion_context ctx;
33197
33198     TRACE("%p, %p, %p\n", params->pCreateInfo, params->pAllocator, params->pInstance);
33199
33200     init_conversion_context(&ctx);
33201     convert_VkInstanceCreateInfo_win64_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
33202     params->result = wine_vkCreateInstance(&pCreateInfo_host, params->pAllocator, params->pInstance, params->client_ptr);
33203     free_conversion_context(&ctx);
33204     return STATUS_SUCCESS;
33205 }
33206
33207 #else /* USE_STRUCT_CONVERSION */
33208
33209 static NTSTATUS thunk32_vkCreateInstance(void *args)
33210 {
33211     struct
33212     {
33213         const VkInstanceCreateInfo32 *pCreateInfo;
33214         const VkAllocationCallbacks *pAllocator;
33215         VkInstance *pInstance;
33216         void *client_ptr;
33217         VkResult result;
33218     } *params = args;
33219     VkInstanceCreateInfo pCreateInfo_host;
33220     struct conversion_context ctx;
33221
33222     TRACE("%p, %p, %p\n", params->pCreateInfo, params->pAllocator, params->pInstance);
33223
33224     init_conversion_context(&ctx);
33225     convert_VkInstanceCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
33226     params->result = wine_vkCreateInstance(&pCreateInfo_host, params->pAllocator, params->pInstance, params->client_ptr);
33227     free_conversion_context(&ctx);
33228     return STATUS_SUCCESS;
33229 }
33230
33231 #endif /* USE_STRUCT_CONVERSION */
33232
33233 #if !defined(USE_STRUCT_CONVERSION)
33234
33235 static NTSTATUS thunk64_vkCreateMicromapEXT(void *args)
33236 {
33237     struct vkCreateMicromapEXT_params *params = args;
33238
33239     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pMicromap);
33240
33241     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateMicromapEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pMicromap);
33242     return STATUS_SUCCESS;
33243 }
33244
33245 #else /* USE_STRUCT_CONVERSION */
33246
33247 static NTSTATUS thunk32_vkCreateMicromapEXT(void *args)
33248 {
33249     struct
33250     {
33251         VkDevice device;
33252         const VkMicromapCreateInfoEXT32 *pCreateInfo;
33253         const VkAllocationCallbacks *pAllocator;
33254         VkMicromapEXT *pMicromap;
33255         VkResult result;
33256     } *params = args;
33257     VkMicromapCreateInfoEXT pCreateInfo_host;
33258
33259     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pMicromap);
33260
33261     convert_VkMicromapCreateInfoEXT_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
33262     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateMicromapEXT(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pMicromap);
33263     return STATUS_SUCCESS;
33264 }
33265
33266 #endif /* USE_STRUCT_CONVERSION */
33267
33268 #if !defined(USE_STRUCT_CONVERSION)
33269
33270 static NTSTATUS thunk64_vkCreateOpticalFlowSessionNV(void *args)
33271 {
33272     struct vkCreateOpticalFlowSessionNV_params *params = args;
33273
33274     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSession);
33275
33276     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSession);
33277     return STATUS_SUCCESS;
33278 }
33279
33280 #else /* USE_STRUCT_CONVERSION */
33281
33282 static NTSTATUS thunk32_vkCreateOpticalFlowSessionNV(void *args)
33283 {
33284     struct
33285     {
33286         VkDevice device;
33287         const VkOpticalFlowSessionCreateInfoNV32 *pCreateInfo;
33288         const VkAllocationCallbacks *pAllocator;
33289         VkOpticalFlowSessionNV *pSession;
33290         VkResult result;
33291     } *params = args;
33292     VkOpticalFlowSessionCreateInfoNV pCreateInfo_host;
33293     struct conversion_context ctx;
33294
33295     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSession);
33296
33297     init_conversion_context(&ctx);
33298     convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
33299     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSession);
33300     free_conversion_context(&ctx);
33301     return STATUS_SUCCESS;
33302 }
33303
33304 #endif /* USE_STRUCT_CONVERSION */
33305
33306 #if !defined(USE_STRUCT_CONVERSION)
33307
33308 static NTSTATUS thunk64_vkCreatePipelineCache(void *args)
33309 {
33310     struct vkCreatePipelineCache_params *params = args;
33311
33312     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineCache);
33313
33314     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineCache(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineCache);
33315     return STATUS_SUCCESS;
33316 }
33317
33318 #else /* USE_STRUCT_CONVERSION */
33319
33320 static NTSTATUS thunk32_vkCreatePipelineCache(void *args)
33321 {
33322     struct
33323     {
33324         VkDevice device;
33325         const VkPipelineCacheCreateInfo32 *pCreateInfo;
33326         const VkAllocationCallbacks *pAllocator;
33327         VkPipelineCache *pPipelineCache;
33328         VkResult result;
33329     } *params = args;
33330     VkPipelineCacheCreateInfo pCreateInfo_host;
33331
33332     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineCache);
33333
33334     convert_VkPipelineCacheCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
33335     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineCache(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pPipelineCache);
33336     return STATUS_SUCCESS;
33337 }
33338
33339 #endif /* USE_STRUCT_CONVERSION */
33340
33341 #if !defined(USE_STRUCT_CONVERSION)
33342
33343 static NTSTATUS thunk64_vkCreatePipelineLayout(void *args)
33344 {
33345     struct vkCreatePipelineLayout_params *params = args;
33346
33347     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineLayout);
33348
33349     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineLayout);
33350     return STATUS_SUCCESS;
33351 }
33352
33353 #else /* USE_STRUCT_CONVERSION */
33354
33355 static NTSTATUS thunk32_vkCreatePipelineLayout(void *args)
33356 {
33357     struct
33358     {
33359         VkDevice device;
33360         const VkPipelineLayoutCreateInfo32 *pCreateInfo;
33361         const VkAllocationCallbacks *pAllocator;
33362         VkPipelineLayout *pPipelineLayout;
33363         VkResult result;
33364     } *params = args;
33365     VkPipelineLayoutCreateInfo pCreateInfo_host;
33366
33367     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineLayout);
33368
33369     convert_VkPipelineLayoutCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
33370     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineLayout(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pPipelineLayout);
33371     return STATUS_SUCCESS;
33372 }
33373
33374 #endif /* USE_STRUCT_CONVERSION */
33375
33376 #if !defined(USE_STRUCT_CONVERSION)
33377
33378 static NTSTATUS thunk64_vkCreatePrivateDataSlot(void *args)
33379 {
33380     struct vkCreatePrivateDataSlot_params *params = args;
33381
33382     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
33383
33384     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlot(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
33385     return STATUS_SUCCESS;
33386 }
33387
33388 #else /* USE_STRUCT_CONVERSION */
33389
33390 static NTSTATUS thunk32_vkCreatePrivateDataSlot(void *args)
33391 {
33392     struct
33393     {
33394         VkDevice device;
33395         const VkPrivateDataSlotCreateInfo32 *pCreateInfo;
33396         const VkAllocationCallbacks *pAllocator;
33397         VkPrivateDataSlot *pPrivateDataSlot;
33398         VkResult result;
33399     } *params = args;
33400     VkPrivateDataSlotCreateInfo pCreateInfo_host;
33401
33402     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
33403
33404     convert_VkPrivateDataSlotCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
33405     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlot(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pPrivateDataSlot);
33406     return STATUS_SUCCESS;
33407 }
33408
33409 #endif /* USE_STRUCT_CONVERSION */
33410
33411 #if !defined(USE_STRUCT_CONVERSION)
33412
33413 static NTSTATUS thunk64_vkCreatePrivateDataSlotEXT(void *args)
33414 {
33415     struct vkCreatePrivateDataSlotEXT_params *params = args;
33416
33417     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
33418
33419     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
33420     return STATUS_SUCCESS;
33421 }
33422
33423 #else /* USE_STRUCT_CONVERSION */
33424
33425 static NTSTATUS thunk32_vkCreatePrivateDataSlotEXT(void *args)
33426 {
33427     struct
33428     {
33429         VkDevice device;
33430         const VkPrivateDataSlotCreateInfo32 *pCreateInfo;
33431         const VkAllocationCallbacks *pAllocator;
33432         VkPrivateDataSlot *pPrivateDataSlot;
33433         VkResult result;
33434     } *params = args;
33435     VkPrivateDataSlotCreateInfo pCreateInfo_host;
33436
33437     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
33438
33439     convert_VkPrivateDataSlotCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
33440     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlotEXT(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pPrivateDataSlot);
33441     return STATUS_SUCCESS;
33442 }
33443
33444 #endif /* USE_STRUCT_CONVERSION */
33445
33446 #if !defined(USE_STRUCT_CONVERSION)
33447
33448 static NTSTATUS thunk64_vkCreateQueryPool(void *args)
33449 {
33450     struct vkCreateQueryPool_params *params = args;
33451
33452     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pQueryPool);
33453
33454     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateQueryPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pQueryPool);
33455     return STATUS_SUCCESS;
33456 }
33457
33458 #else /* USE_STRUCT_CONVERSION */
33459
33460 static NTSTATUS thunk32_vkCreateQueryPool(void *args)
33461 {
33462     struct
33463     {
33464         VkDevice device;
33465         const VkQueryPoolCreateInfo32 *pCreateInfo;
33466         const VkAllocationCallbacks *pAllocator;
33467         VkQueryPool *pQueryPool;
33468         VkResult result;
33469     } *params = args;
33470     VkQueryPoolCreateInfo pCreateInfo_host;
33471     struct conversion_context ctx;
33472
33473     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pQueryPool);
33474
33475     init_conversion_context(&ctx);
33476     convert_VkQueryPoolCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
33477     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateQueryPool(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pQueryPool);
33478     free_conversion_context(&ctx);
33479     return STATUS_SUCCESS;
33480 }
33481
33482 #endif /* USE_STRUCT_CONVERSION */
33483
33484 #if !defined(USE_STRUCT_CONVERSION)
33485
33486 static NTSTATUS thunk64_vkCreateRayTracingPipelinesKHR(void *args)
33487 {
33488     struct vkCreateRayTracingPipelinesKHR_params *params = args;
33489     const VkRayTracingPipelineCreateInfoKHR *pCreateInfos_host;
33490     struct conversion_context ctx;
33491
33492     TRACE("%p, 0x%s, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
33493
33494     init_conversion_context(&ctx);
33495     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoKHR_array_win64_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
33496     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRayTracingPipelinesKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, params->pPipelines);
33497     free_conversion_context(&ctx);
33498     return STATUS_SUCCESS;
33499 }
33500
33501 #else /* USE_STRUCT_CONVERSION */
33502
33503 static NTSTATUS thunk32_vkCreateRayTracingPipelinesKHR(void *args)
33504 {
33505     struct
33506     {
33507         VkDevice device;
33508         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
33509         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
33510         uint32_t createInfoCount;
33511         const VkRayTracingPipelineCreateInfoKHR32 *pCreateInfos;
33512         const VkAllocationCallbacks *pAllocator;
33513         VkPipeline *pPipelines;
33514         VkResult result;
33515     } *params = args;
33516     const VkRayTracingPipelineCreateInfoKHR *pCreateInfos_host;
33517     struct conversion_context ctx;
33518
33519     TRACE("%p, 0x%s, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
33520
33521     init_conversion_context(&ctx);
33522     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
33523     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRayTracingPipelinesKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, params->pPipelines);
33524     convert_VkRayTracingPipelineCreateInfoKHR_array_host_to_win32(pCreateInfos_host, params->pCreateInfos, params->createInfoCount);
33525     free_conversion_context(&ctx);
33526     return STATUS_SUCCESS;
33527 }
33528
33529 #endif /* USE_STRUCT_CONVERSION */
33530
33531 #if !defined(USE_STRUCT_CONVERSION)
33532
33533 static NTSTATUS thunk64_vkCreateRayTracingPipelinesNV(void *args)
33534 {
33535     struct vkCreateRayTracingPipelinesNV_params *params = args;
33536     const VkRayTracingPipelineCreateInfoNV *pCreateInfos_host;
33537     struct conversion_context ctx;
33538
33539     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
33540
33541     init_conversion_context(&ctx);
33542     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoNV_array_win64_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
33543     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRayTracingPipelinesNV(wine_device_from_handle(params->device)->device, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, params->pPipelines);
33544     free_conversion_context(&ctx);
33545     return STATUS_SUCCESS;
33546 }
33547
33548 #else /* USE_STRUCT_CONVERSION */
33549
33550 static NTSTATUS thunk32_vkCreateRayTracingPipelinesNV(void *args)
33551 {
33552     struct
33553     {
33554         VkDevice device;
33555         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
33556         uint32_t createInfoCount;
33557         const VkRayTracingPipelineCreateInfoNV32 *pCreateInfos;
33558         const VkAllocationCallbacks *pAllocator;
33559         VkPipeline *pPipelines;
33560         VkResult result;
33561     } *params = args;
33562     const VkRayTracingPipelineCreateInfoNV *pCreateInfos_host;
33563     struct conversion_context ctx;
33564
33565     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
33566
33567     init_conversion_context(&ctx);
33568     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoNV_array_win32_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
33569     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRayTracingPipelinesNV(wine_device_from_handle(params->device)->device, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, params->pPipelines);
33570     convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32(pCreateInfos_host, params->pCreateInfos, params->createInfoCount);
33571     free_conversion_context(&ctx);
33572     return STATUS_SUCCESS;
33573 }
33574
33575 #endif /* USE_STRUCT_CONVERSION */
33576
33577 #if !defined(USE_STRUCT_CONVERSION)
33578
33579 static NTSTATUS thunk64_vkCreateRenderPass(void *args)
33580 {
33581     struct vkCreateRenderPass_params *params = args;
33582
33583     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33584
33585     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
33586     return STATUS_SUCCESS;
33587 }
33588
33589 #else /* USE_STRUCT_CONVERSION */
33590
33591 static NTSTATUS thunk32_vkCreateRenderPass(void *args)
33592 {
33593     struct
33594     {
33595         VkDevice device;
33596         const VkRenderPassCreateInfo32 *pCreateInfo;
33597         const VkAllocationCallbacks *pAllocator;
33598         VkRenderPass *pRenderPass;
33599         VkResult result;
33600     } *params = args;
33601     VkRenderPassCreateInfo pCreateInfo_host;
33602     struct conversion_context ctx;
33603
33604     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33605
33606     init_conversion_context(&ctx);
33607     convert_VkRenderPassCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
33608     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pRenderPass);
33609     free_conversion_context(&ctx);
33610     return STATUS_SUCCESS;
33611 }
33612
33613 #endif /* USE_STRUCT_CONVERSION */
33614
33615 #if !defined(USE_STRUCT_CONVERSION)
33616
33617 static NTSTATUS thunk64_vkCreateRenderPass2(void *args)
33618 {
33619     struct vkCreateRenderPass2_params *params = args;
33620
33621     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33622
33623     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
33624     return STATUS_SUCCESS;
33625 }
33626
33627 #else /* USE_STRUCT_CONVERSION */
33628
33629 static NTSTATUS thunk32_vkCreateRenderPass2(void *args)
33630 {
33631     struct
33632     {
33633         VkDevice device;
33634         const VkRenderPassCreateInfo232 *pCreateInfo;
33635         const VkAllocationCallbacks *pAllocator;
33636         VkRenderPass *pRenderPass;
33637         VkResult result;
33638     } *params = args;
33639     VkRenderPassCreateInfo2 pCreateInfo_host;
33640     struct conversion_context ctx;
33641
33642     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33643
33644     init_conversion_context(&ctx);
33645     convert_VkRenderPassCreateInfo2_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
33646     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pRenderPass);
33647     free_conversion_context(&ctx);
33648     return STATUS_SUCCESS;
33649 }
33650
33651 #endif /* USE_STRUCT_CONVERSION */
33652
33653 #if !defined(USE_STRUCT_CONVERSION)
33654
33655 static NTSTATUS thunk64_vkCreateRenderPass2KHR(void *args)
33656 {
33657     struct vkCreateRenderPass2KHR_params *params = args;
33658
33659     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33660
33661     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2KHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
33662     return STATUS_SUCCESS;
33663 }
33664
33665 #else /* USE_STRUCT_CONVERSION */
33666
33667 static NTSTATUS thunk32_vkCreateRenderPass2KHR(void *args)
33668 {
33669     struct
33670     {
33671         VkDevice device;
33672         const VkRenderPassCreateInfo232 *pCreateInfo;
33673         const VkAllocationCallbacks *pAllocator;
33674         VkRenderPass *pRenderPass;
33675         VkResult result;
33676     } *params = args;
33677     VkRenderPassCreateInfo2 pCreateInfo_host;
33678     struct conversion_context ctx;
33679
33680     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33681
33682     init_conversion_context(&ctx);
33683     convert_VkRenderPassCreateInfo2_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
33684     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2KHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pRenderPass);
33685     free_conversion_context(&ctx);
33686     return STATUS_SUCCESS;
33687 }
33688
33689 #endif /* USE_STRUCT_CONVERSION */
33690
33691 #if !defined(USE_STRUCT_CONVERSION)
33692
33693 static NTSTATUS thunk64_vkCreateSampler(void *args)
33694 {
33695     struct vkCreateSampler_params *params = args;
33696
33697     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSampler);
33698
33699     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSampler(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSampler);
33700     return STATUS_SUCCESS;
33701 }
33702
33703 #else /* USE_STRUCT_CONVERSION */
33704
33705 static NTSTATUS thunk32_vkCreateSampler(void *args)
33706 {
33707     struct
33708     {
33709         VkDevice device;
33710         const VkSamplerCreateInfo32 *pCreateInfo;
33711         const VkAllocationCallbacks *pAllocator;
33712         VkSampler *pSampler;
33713         VkResult result;
33714     } *params = args;
33715     VkSamplerCreateInfo pCreateInfo_host;
33716     struct conversion_context ctx;
33717
33718     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSampler);
33719
33720     init_conversion_context(&ctx);
33721     convert_VkSamplerCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
33722     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSampler(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSampler);
33723     free_conversion_context(&ctx);
33724     return STATUS_SUCCESS;
33725 }
33726
33727 #endif /* USE_STRUCT_CONVERSION */
33728
33729 #if !defined(USE_STRUCT_CONVERSION)
33730
33731 static NTSTATUS thunk64_vkCreateSamplerYcbcrConversion(void *args)
33732 {
33733     struct vkCreateSamplerYcbcrConversion_params *params = args;
33734
33735     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
33736
33737     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
33738     return STATUS_SUCCESS;
33739 }
33740
33741 #else /* USE_STRUCT_CONVERSION */
33742
33743 static NTSTATUS thunk32_vkCreateSamplerYcbcrConversion(void *args)
33744 {
33745     struct
33746     {
33747         VkDevice device;
33748         const VkSamplerYcbcrConversionCreateInfo32 *pCreateInfo;
33749         const VkAllocationCallbacks *pAllocator;
33750         VkSamplerYcbcrConversion *pYcbcrConversion;
33751         VkResult result;
33752     } *params = args;
33753     VkSamplerYcbcrConversionCreateInfo pCreateInfo_host;
33754
33755     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
33756
33757     convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
33758     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversion(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pYcbcrConversion);
33759     return STATUS_SUCCESS;
33760 }
33761
33762 #endif /* USE_STRUCT_CONVERSION */
33763
33764 #if !defined(USE_STRUCT_CONVERSION)
33765
33766 static NTSTATUS thunk64_vkCreateSamplerYcbcrConversionKHR(void *args)
33767 {
33768     struct vkCreateSamplerYcbcrConversionKHR_params *params = args;
33769
33770     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
33771
33772     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
33773     return STATUS_SUCCESS;
33774 }
33775
33776 #else /* USE_STRUCT_CONVERSION */
33777
33778 static NTSTATUS thunk32_vkCreateSamplerYcbcrConversionKHR(void *args)
33779 {
33780     struct
33781     {
33782         VkDevice device;
33783         const VkSamplerYcbcrConversionCreateInfo32 *pCreateInfo;
33784         const VkAllocationCallbacks *pAllocator;
33785         VkSamplerYcbcrConversion *pYcbcrConversion;
33786         VkResult result;
33787     } *params = args;
33788     VkSamplerYcbcrConversionCreateInfo pCreateInfo_host;
33789
33790     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
33791
33792     convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
33793     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pYcbcrConversion);
33794     return STATUS_SUCCESS;
33795 }
33796
33797 #endif /* USE_STRUCT_CONVERSION */
33798
33799 #if !defined(USE_STRUCT_CONVERSION)
33800
33801 static NTSTATUS thunk64_vkCreateSemaphore(void *args)
33802 {
33803     struct vkCreateSemaphore_params *params = args;
33804
33805     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSemaphore);
33806
33807     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSemaphore(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSemaphore);
33808     return STATUS_SUCCESS;
33809 }
33810
33811 #else /* USE_STRUCT_CONVERSION */
33812
33813 static NTSTATUS thunk32_vkCreateSemaphore(void *args)
33814 {
33815     struct
33816     {
33817         VkDevice device;
33818         const VkSemaphoreCreateInfo32 *pCreateInfo;
33819         const VkAllocationCallbacks *pAllocator;
33820         VkSemaphore *pSemaphore;
33821         VkResult result;
33822     } *params = args;
33823     VkSemaphoreCreateInfo pCreateInfo_host;
33824     struct conversion_context ctx;
33825
33826     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSemaphore);
33827
33828     init_conversion_context(&ctx);
33829     convert_VkSemaphoreCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
33830     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSemaphore(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSemaphore);
33831     free_conversion_context(&ctx);
33832     return STATUS_SUCCESS;
33833 }
33834
33835 #endif /* USE_STRUCT_CONVERSION */
33836
33837 #if !defined(USE_STRUCT_CONVERSION)
33838
33839 static NTSTATUS thunk64_vkCreateShaderModule(void *args)
33840 {
33841     struct vkCreateShaderModule_params *params = args;
33842
33843     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pShaderModule);
33844
33845     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateShaderModule(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pShaderModule);
33846     return STATUS_SUCCESS;
33847 }
33848
33849 #else /* USE_STRUCT_CONVERSION */
33850
33851 static NTSTATUS thunk32_vkCreateShaderModule(void *args)
33852 {
33853     struct
33854     {
33855         VkDevice device;
33856         const VkShaderModuleCreateInfo32 *pCreateInfo;
33857         const VkAllocationCallbacks *pAllocator;
33858         VkShaderModule *pShaderModule;
33859         VkResult result;
33860     } *params = args;
33861     VkShaderModuleCreateInfo pCreateInfo_host;
33862     struct conversion_context ctx;
33863
33864     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pShaderModule);
33865
33866     init_conversion_context(&ctx);
33867     convert_VkShaderModuleCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
33868     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateShaderModule(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pShaderModule);
33869     free_conversion_context(&ctx);
33870     return STATUS_SUCCESS;
33871 }
33872
33873 #endif /* USE_STRUCT_CONVERSION */
33874
33875 #if !defined(USE_STRUCT_CONVERSION)
33876
33877 static NTSTATUS thunk64_vkCreateSwapchainKHR(void *args)
33878 {
33879     struct vkCreateSwapchainKHR_params *params = args;
33880     VkSwapchainCreateInfoKHR pCreateInfo_host;
33881
33882     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSwapchain);
33883
33884     convert_VkSwapchainCreateInfoKHR_win64_to_host(params->pCreateInfo, &pCreateInfo_host);
33885     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSwapchainKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSwapchain);
33886     return STATUS_SUCCESS;
33887 }
33888
33889 #else /* USE_STRUCT_CONVERSION */
33890
33891 static NTSTATUS thunk32_vkCreateSwapchainKHR(void *args)
33892 {
33893     struct
33894     {
33895         VkDevice device;
33896         const VkSwapchainCreateInfoKHR32 *pCreateInfo;
33897         const VkAllocationCallbacks *pAllocator;
33898         VkSwapchainKHR *pSwapchain;
33899         VkResult result;
33900     } *params = args;
33901     VkSwapchainCreateInfoKHR pCreateInfo_host;
33902     struct conversion_context ctx;
33903
33904     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSwapchain);
33905
33906     init_conversion_context(&ctx);
33907     convert_VkSwapchainCreateInfoKHR_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
33908     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSwapchainKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSwapchain);
33909     free_conversion_context(&ctx);
33910     return STATUS_SUCCESS;
33911 }
33912
33913 #endif /* USE_STRUCT_CONVERSION */
33914
33915 #if !defined(USE_STRUCT_CONVERSION)
33916
33917 static NTSTATUS thunk64_vkCreateValidationCacheEXT(void *args)
33918 {
33919     struct vkCreateValidationCacheEXT_params *params = args;
33920
33921     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pValidationCache);
33922
33923     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateValidationCacheEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pValidationCache);
33924     return STATUS_SUCCESS;
33925 }
33926
33927 #else /* USE_STRUCT_CONVERSION */
33928
33929 static NTSTATUS thunk32_vkCreateValidationCacheEXT(void *args)
33930 {
33931     struct
33932     {
33933         VkDevice device;
33934         const VkValidationCacheCreateInfoEXT32 *pCreateInfo;
33935         const VkAllocationCallbacks *pAllocator;
33936         VkValidationCacheEXT *pValidationCache;
33937         VkResult result;
33938     } *params = args;
33939     VkValidationCacheCreateInfoEXT pCreateInfo_host;
33940
33941     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pValidationCache);
33942
33943     convert_VkValidationCacheCreateInfoEXT_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
33944     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateValidationCacheEXT(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pValidationCache);
33945     return STATUS_SUCCESS;
33946 }
33947
33948 #endif /* USE_STRUCT_CONVERSION */
33949
33950 #if !defined(USE_STRUCT_CONVERSION)
33951
33952 static NTSTATUS thunk64_vkCreateWin32SurfaceKHR(void *args)
33953 {
33954     struct vkCreateWin32SurfaceKHR_params *params = args;
33955
33956     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
33957
33958     params->result = wine_vkCreateWin32SurfaceKHR(params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
33959     return STATUS_SUCCESS;
33960 }
33961
33962 #else /* USE_STRUCT_CONVERSION */
33963
33964 static NTSTATUS thunk32_vkCreateWin32SurfaceKHR(void *args)
33965 {
33966     struct
33967     {
33968         VkInstance instance;
33969         const VkWin32SurfaceCreateInfoKHR32 *pCreateInfo;
33970         const VkAllocationCallbacks *pAllocator;
33971         VkSurfaceKHR *pSurface;
33972         VkResult result;
33973     } *params = args;
33974     VkWin32SurfaceCreateInfoKHR pCreateInfo_host;
33975
33976     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
33977
33978     convert_VkWin32SurfaceCreateInfoKHR_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
33979     params->result = wine_vkCreateWin32SurfaceKHR(params->instance, &pCreateInfo_host, params->pAllocator, params->pSurface);
33980     return STATUS_SUCCESS;
33981 }
33982
33983 #endif /* USE_STRUCT_CONVERSION */
33984
33985 #if !defined(USE_STRUCT_CONVERSION)
33986
33987 static NTSTATUS thunk64_vkDebugMarkerSetObjectNameEXT(void *args)
33988 {
33989     struct vkDebugMarkerSetObjectNameEXT_params *params = args;
33990     VkDebugMarkerObjectNameInfoEXT pNameInfo_host;
33991
33992     TRACE("%p, %p\n", params->device, params->pNameInfo);
33993
33994     convert_VkDebugMarkerObjectNameInfoEXT_win64_to_host(params->pNameInfo, &pNameInfo_host);
33995     params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
33996     return STATUS_SUCCESS;
33997 }
33998
33999 #else /* USE_STRUCT_CONVERSION */
34000
34001 static NTSTATUS thunk32_vkDebugMarkerSetObjectNameEXT(void *args)
34002 {
34003     struct
34004     {
34005         VkDevice device;
34006         const VkDebugMarkerObjectNameInfoEXT32 *pNameInfo;
34007         VkResult result;
34008     } *params = args;
34009     VkDebugMarkerObjectNameInfoEXT pNameInfo_host;
34010
34011     TRACE("%p, %p\n", params->device, params->pNameInfo);
34012
34013     convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host(params->pNameInfo, &pNameInfo_host);
34014     params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
34015     return STATUS_SUCCESS;
34016 }
34017
34018 #endif /* USE_STRUCT_CONVERSION */
34019
34020 #if !defined(USE_STRUCT_CONVERSION)
34021
34022 static NTSTATUS thunk64_vkDebugMarkerSetObjectTagEXT(void *args)
34023 {
34024     struct vkDebugMarkerSetObjectTagEXT_params *params = args;
34025     VkDebugMarkerObjectTagInfoEXT pTagInfo_host;
34026
34027     TRACE("%p, %p\n", params->device, params->pTagInfo);
34028
34029     convert_VkDebugMarkerObjectTagInfoEXT_win64_to_host(params->pTagInfo, &pTagInfo_host);
34030     params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
34031     return STATUS_SUCCESS;
34032 }
34033
34034 #else /* USE_STRUCT_CONVERSION */
34035
34036 static NTSTATUS thunk32_vkDebugMarkerSetObjectTagEXT(void *args)
34037 {
34038     struct
34039     {
34040         VkDevice device;
34041         const VkDebugMarkerObjectTagInfoEXT32 *pTagInfo;
34042         VkResult result;
34043     } *params = args;
34044     VkDebugMarkerObjectTagInfoEXT pTagInfo_host;
34045
34046     TRACE("%p, %p\n", params->device, params->pTagInfo);
34047
34048     convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host(params->pTagInfo, &pTagInfo_host);
34049     params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
34050     return STATUS_SUCCESS;
34051 }
34052
34053 #endif /* USE_STRUCT_CONVERSION */
34054
34055 #if !defined(USE_STRUCT_CONVERSION)
34056
34057 static NTSTATUS thunk64_vkDebugReportMessageEXT(void *args)
34058 {
34059     struct vkDebugReportMessageEXT_params *params = args;
34060
34061     TRACE("%p, %#x, %#x, 0x%s, 0x%s, %d, %p, %p\n", params->instance, params->flags, params->objectType, wine_dbgstr_longlong(params->object), wine_dbgstr_longlong(params->location), params->messageCode, params->pLayerPrefix, params->pMessage);
34062
34063     wine_instance_from_handle(params->instance)->funcs.p_vkDebugReportMessageEXT(wine_instance_from_handle(params->instance)->instance, params->flags, params->objectType, wine_vk_unwrap_handle(params->objectType, params->object), params->location, params->messageCode, params->pLayerPrefix, params->pMessage);
34064     return STATUS_SUCCESS;
34065 }
34066
34067 #else /* USE_STRUCT_CONVERSION */
34068
34069 static NTSTATUS thunk32_vkDebugReportMessageEXT(void *args)
34070 {
34071     struct
34072     {
34073         VkInstance instance;
34074         VkDebugReportFlagsEXT flags;
34075         VkDebugReportObjectTypeEXT objectType;
34076         uint64_t DECLSPEC_ALIGN(8) object;
34077         size_t location;
34078         int32_t messageCode;
34079         const char *pLayerPrefix;
34080         const char *pMessage;
34081     } *params = args;
34082
34083     TRACE("%p, %#x, %#x, 0x%s, 0x%s, %d, %p, %p\n", params->instance, params->flags, params->objectType, wine_dbgstr_longlong(params->object), wine_dbgstr_longlong(params->location), params->messageCode, params->pLayerPrefix, params->pMessage);
34084
34085     wine_instance_from_handle(params->instance)->funcs.p_vkDebugReportMessageEXT(wine_instance_from_handle(params->instance)->instance, params->flags, params->objectType, wine_vk_unwrap_handle(params->objectType, params->object), params->location, params->messageCode, params->pLayerPrefix, params->pMessage);
34086     return STATUS_SUCCESS;
34087 }
34088
34089 #endif /* USE_STRUCT_CONVERSION */
34090
34091 #if !defined(USE_STRUCT_CONVERSION)
34092
34093 static NTSTATUS thunk64_vkDeferredOperationJoinKHR(void *args)
34094 {
34095     struct vkDeferredOperationJoinKHR_params *params = args;
34096
34097     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
34098
34099     params->result = wine_device_from_handle(params->device)->funcs.p_vkDeferredOperationJoinKHR(wine_device_from_handle(params->device)->device, params->operation);
34100     return STATUS_SUCCESS;
34101 }
34102
34103 #else /* USE_STRUCT_CONVERSION */
34104
34105 static NTSTATUS thunk32_vkDeferredOperationJoinKHR(void *args)
34106 {
34107     struct
34108     {
34109         VkDevice device;
34110         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
34111         VkResult result;
34112     } *params = args;
34113
34114     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
34115
34116     params->result = wine_device_from_handle(params->device)->funcs.p_vkDeferredOperationJoinKHR(wine_device_from_handle(params->device)->device, params->operation);
34117     return STATUS_SUCCESS;
34118 }
34119
34120 #endif /* USE_STRUCT_CONVERSION */
34121
34122 #if !defined(USE_STRUCT_CONVERSION)
34123
34124 static NTSTATUS thunk64_vkDestroyAccelerationStructureKHR(void *args)
34125 {
34126     struct vkDestroyAccelerationStructureKHR_params *params = args;
34127
34128     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
34129
34130     wine_device_from_handle(params->device)->funcs.p_vkDestroyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->accelerationStructure, NULL);
34131     return STATUS_SUCCESS;
34132 }
34133
34134 #else /* USE_STRUCT_CONVERSION */
34135
34136 static NTSTATUS thunk32_vkDestroyAccelerationStructureKHR(void *args)
34137 {
34138     struct
34139     {
34140         VkDevice device;
34141         VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
34142         const VkAllocationCallbacks *pAllocator;
34143     } *params = args;
34144
34145     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
34146
34147     wine_device_from_handle(params->device)->funcs.p_vkDestroyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->accelerationStructure, NULL);
34148     return STATUS_SUCCESS;
34149 }
34150
34151 #endif /* USE_STRUCT_CONVERSION */
34152
34153 #if !defined(USE_STRUCT_CONVERSION)
34154
34155 static NTSTATUS thunk64_vkDestroyAccelerationStructureNV(void *args)
34156 {
34157     struct vkDestroyAccelerationStructureNV_params *params = args;
34158
34159     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
34160
34161     wine_device_from_handle(params->device)->funcs.p_vkDestroyAccelerationStructureNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, NULL);
34162     return STATUS_SUCCESS;
34163 }
34164
34165 #else /* USE_STRUCT_CONVERSION */
34166
34167 static NTSTATUS thunk32_vkDestroyAccelerationStructureNV(void *args)
34168 {
34169     struct
34170     {
34171         VkDevice device;
34172         VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
34173         const VkAllocationCallbacks *pAllocator;
34174     } *params = args;
34175
34176     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
34177
34178     wine_device_from_handle(params->device)->funcs.p_vkDestroyAccelerationStructureNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, NULL);
34179     return STATUS_SUCCESS;
34180 }
34181
34182 #endif /* USE_STRUCT_CONVERSION */
34183
34184 #if !defined(USE_STRUCT_CONVERSION)
34185
34186 static NTSTATUS thunk64_vkDestroyBuffer(void *args)
34187 {
34188     struct vkDestroyBuffer_params *params = args;
34189
34190     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->buffer), params->pAllocator);
34191
34192     wine_device_from_handle(params->device)->funcs.p_vkDestroyBuffer(wine_device_from_handle(params->device)->device, params->buffer, NULL);
34193     return STATUS_SUCCESS;
34194 }
34195
34196 #else /* USE_STRUCT_CONVERSION */
34197
34198 static NTSTATUS thunk32_vkDestroyBuffer(void *args)
34199 {
34200     struct
34201     {
34202         VkDevice device;
34203         VkBuffer DECLSPEC_ALIGN(8) buffer;
34204         const VkAllocationCallbacks *pAllocator;
34205     } *params = args;
34206
34207     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->buffer), params->pAllocator);
34208
34209     wine_device_from_handle(params->device)->funcs.p_vkDestroyBuffer(wine_device_from_handle(params->device)->device, params->buffer, NULL);
34210     return STATUS_SUCCESS;
34211 }
34212
34213 #endif /* USE_STRUCT_CONVERSION */
34214
34215 #if !defined(USE_STRUCT_CONVERSION)
34216
34217 static NTSTATUS thunk64_vkDestroyBufferView(void *args)
34218 {
34219     struct vkDestroyBufferView_params *params = args;
34220
34221     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->bufferView), params->pAllocator);
34222
34223     wine_device_from_handle(params->device)->funcs.p_vkDestroyBufferView(wine_device_from_handle(params->device)->device, params->bufferView, NULL);
34224     return STATUS_SUCCESS;
34225 }
34226
34227 #else /* USE_STRUCT_CONVERSION */
34228
34229 static NTSTATUS thunk32_vkDestroyBufferView(void *args)
34230 {
34231     struct
34232     {
34233         VkDevice device;
34234         VkBufferView DECLSPEC_ALIGN(8) bufferView;
34235         const VkAllocationCallbacks *pAllocator;
34236     } *params = args;
34237
34238     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->bufferView), params->pAllocator);
34239
34240     wine_device_from_handle(params->device)->funcs.p_vkDestroyBufferView(wine_device_from_handle(params->device)->device, params->bufferView, NULL);
34241     return STATUS_SUCCESS;
34242 }
34243
34244 #endif /* USE_STRUCT_CONVERSION */
34245
34246 #if !defined(USE_STRUCT_CONVERSION)
34247
34248 static NTSTATUS thunk64_vkDestroyCommandPool(void *args)
34249 {
34250     struct vkDestroyCommandPool_params *params = args;
34251
34252     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->commandPool), params->pAllocator);
34253
34254     wine_vkDestroyCommandPool(params->device, params->commandPool, params->pAllocator);
34255     return STATUS_SUCCESS;
34256 }
34257
34258 #else /* USE_STRUCT_CONVERSION */
34259
34260 static NTSTATUS thunk32_vkDestroyCommandPool(void *args)
34261 {
34262     struct
34263     {
34264         VkDevice device;
34265         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
34266         const VkAllocationCallbacks *pAllocator;
34267     } *params = args;
34268
34269     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->commandPool), params->pAllocator);
34270
34271     wine_vkDestroyCommandPool(params->device, params->commandPool, params->pAllocator);
34272     return STATUS_SUCCESS;
34273 }
34274
34275 #endif /* USE_STRUCT_CONVERSION */
34276
34277 #if !defined(USE_STRUCT_CONVERSION)
34278
34279 static NTSTATUS thunk64_vkDestroyCuFunctionNVX(void *args)
34280 {
34281     struct vkDestroyCuFunctionNVX_params *params = args;
34282
34283     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->function), params->pAllocator);
34284
34285     wine_device_from_handle(params->device)->funcs.p_vkDestroyCuFunctionNVX(wine_device_from_handle(params->device)->device, params->function, NULL);
34286     return STATUS_SUCCESS;
34287 }
34288
34289 #else /* USE_STRUCT_CONVERSION */
34290
34291 static NTSTATUS thunk32_vkDestroyCuFunctionNVX(void *args)
34292 {
34293     struct
34294     {
34295         VkDevice device;
34296         VkCuFunctionNVX DECLSPEC_ALIGN(8) function;
34297         const VkAllocationCallbacks *pAllocator;
34298     } *params = args;
34299
34300     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->function), params->pAllocator);
34301
34302     wine_device_from_handle(params->device)->funcs.p_vkDestroyCuFunctionNVX(wine_device_from_handle(params->device)->device, params->function, NULL);
34303     return STATUS_SUCCESS;
34304 }
34305
34306 #endif /* USE_STRUCT_CONVERSION */
34307
34308 #if !defined(USE_STRUCT_CONVERSION)
34309
34310 static NTSTATUS thunk64_vkDestroyCuModuleNVX(void *args)
34311 {
34312     struct vkDestroyCuModuleNVX_params *params = args;
34313
34314     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->module), params->pAllocator);
34315
34316     wine_device_from_handle(params->device)->funcs.p_vkDestroyCuModuleNVX(wine_device_from_handle(params->device)->device, params->module, NULL);
34317     return STATUS_SUCCESS;
34318 }
34319
34320 #else /* USE_STRUCT_CONVERSION */
34321
34322 static NTSTATUS thunk32_vkDestroyCuModuleNVX(void *args)
34323 {
34324     struct
34325     {
34326         VkDevice device;
34327         VkCuModuleNVX DECLSPEC_ALIGN(8) module;
34328         const VkAllocationCallbacks *pAllocator;
34329     } *params = args;
34330
34331     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->module), params->pAllocator);
34332
34333     wine_device_from_handle(params->device)->funcs.p_vkDestroyCuModuleNVX(wine_device_from_handle(params->device)->device, params->module, NULL);
34334     return STATUS_SUCCESS;
34335 }
34336
34337 #endif /* USE_STRUCT_CONVERSION */
34338
34339 #if !defined(USE_STRUCT_CONVERSION)
34340
34341 static NTSTATUS thunk64_vkDestroyDebugReportCallbackEXT(void *args)
34342 {
34343     struct vkDestroyDebugReportCallbackEXT_params *params = args;
34344
34345     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->callback), params->pAllocator);
34346
34347     wine_vkDestroyDebugReportCallbackEXT(params->instance, params->callback, params->pAllocator);
34348     return STATUS_SUCCESS;
34349 }
34350
34351 #else /* USE_STRUCT_CONVERSION */
34352
34353 static NTSTATUS thunk32_vkDestroyDebugReportCallbackEXT(void *args)
34354 {
34355     struct
34356     {
34357         VkInstance instance;
34358         VkDebugReportCallbackEXT DECLSPEC_ALIGN(8) callback;
34359         const VkAllocationCallbacks *pAllocator;
34360     } *params = args;
34361
34362     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->callback), params->pAllocator);
34363
34364     wine_vkDestroyDebugReportCallbackEXT(params->instance, params->callback, params->pAllocator);
34365     return STATUS_SUCCESS;
34366 }
34367
34368 #endif /* USE_STRUCT_CONVERSION */
34369
34370 #if !defined(USE_STRUCT_CONVERSION)
34371
34372 static NTSTATUS thunk64_vkDestroyDebugUtilsMessengerEXT(void *args)
34373 {
34374     struct vkDestroyDebugUtilsMessengerEXT_params *params = args;
34375
34376     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->messenger), params->pAllocator);
34377
34378     wine_vkDestroyDebugUtilsMessengerEXT(params->instance, params->messenger, params->pAllocator);
34379     return STATUS_SUCCESS;
34380 }
34381
34382 #else /* USE_STRUCT_CONVERSION */
34383
34384 static NTSTATUS thunk32_vkDestroyDebugUtilsMessengerEXT(void *args)
34385 {
34386     struct
34387     {
34388         VkInstance instance;
34389         VkDebugUtilsMessengerEXT DECLSPEC_ALIGN(8) messenger;
34390         const VkAllocationCallbacks *pAllocator;
34391     } *params = args;
34392
34393     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->messenger), params->pAllocator);
34394
34395     wine_vkDestroyDebugUtilsMessengerEXT(params->instance, params->messenger, params->pAllocator);
34396     return STATUS_SUCCESS;
34397 }
34398
34399 #endif /* USE_STRUCT_CONVERSION */
34400
34401 #if !defined(USE_STRUCT_CONVERSION)
34402
34403 static NTSTATUS thunk64_vkDestroyDeferredOperationKHR(void *args)
34404 {
34405     struct vkDestroyDeferredOperationKHR_params *params = args;
34406
34407     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->operation), params->pAllocator);
34408
34409     wine_device_from_handle(params->device)->funcs.p_vkDestroyDeferredOperationKHR(wine_device_from_handle(params->device)->device, params->operation, NULL);
34410     return STATUS_SUCCESS;
34411 }
34412
34413 #else /* USE_STRUCT_CONVERSION */
34414
34415 static NTSTATUS thunk32_vkDestroyDeferredOperationKHR(void *args)
34416 {
34417     struct
34418     {
34419         VkDevice device;
34420         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
34421         const VkAllocationCallbacks *pAllocator;
34422     } *params = args;
34423
34424     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->operation), params->pAllocator);
34425
34426     wine_device_from_handle(params->device)->funcs.p_vkDestroyDeferredOperationKHR(wine_device_from_handle(params->device)->device, params->operation, NULL);
34427     return STATUS_SUCCESS;
34428 }
34429
34430 #endif /* USE_STRUCT_CONVERSION */
34431
34432 #if !defined(USE_STRUCT_CONVERSION)
34433
34434 static NTSTATUS thunk64_vkDestroyDescriptorPool(void *args)
34435 {
34436     struct vkDestroyDescriptorPool_params *params = args;
34437
34438     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->pAllocator);
34439
34440     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, NULL);
34441     return STATUS_SUCCESS;
34442 }
34443
34444 #else /* USE_STRUCT_CONVERSION */
34445
34446 static NTSTATUS thunk32_vkDestroyDescriptorPool(void *args)
34447 {
34448     struct
34449     {
34450         VkDevice device;
34451         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
34452         const VkAllocationCallbacks *pAllocator;
34453     } *params = args;
34454
34455     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->pAllocator);
34456
34457     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, NULL);
34458     return STATUS_SUCCESS;
34459 }
34460
34461 #endif /* USE_STRUCT_CONVERSION */
34462
34463 #if !defined(USE_STRUCT_CONVERSION)
34464
34465 static NTSTATUS thunk64_vkDestroyDescriptorSetLayout(void *args)
34466 {
34467     struct vkDestroyDescriptorSetLayout_params *params = args;
34468
34469     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSetLayout), params->pAllocator);
34470
34471     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->descriptorSetLayout, NULL);
34472     return STATUS_SUCCESS;
34473 }
34474
34475 #else /* USE_STRUCT_CONVERSION */
34476
34477 static NTSTATUS thunk32_vkDestroyDescriptorSetLayout(void *args)
34478 {
34479     struct
34480     {
34481         VkDevice device;
34482         VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
34483         const VkAllocationCallbacks *pAllocator;
34484     } *params = args;
34485
34486     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSetLayout), params->pAllocator);
34487
34488     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->descriptorSetLayout, NULL);
34489     return STATUS_SUCCESS;
34490 }
34491
34492 #endif /* USE_STRUCT_CONVERSION */
34493
34494 #if !defined(USE_STRUCT_CONVERSION)
34495
34496 static NTSTATUS thunk64_vkDestroyDescriptorUpdateTemplate(void *args)
34497 {
34498     struct vkDestroyDescriptorUpdateTemplate_params *params = args;
34499
34500     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
34501
34502     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, params->descriptorUpdateTemplate, NULL);
34503     return STATUS_SUCCESS;
34504 }
34505
34506 #else /* USE_STRUCT_CONVERSION */
34507
34508 static NTSTATUS thunk32_vkDestroyDescriptorUpdateTemplate(void *args)
34509 {
34510     struct
34511     {
34512         VkDevice device;
34513         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
34514         const VkAllocationCallbacks *pAllocator;
34515     } *params = args;
34516
34517     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
34518
34519     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, params->descriptorUpdateTemplate, NULL);
34520     return STATUS_SUCCESS;
34521 }
34522
34523 #endif /* USE_STRUCT_CONVERSION */
34524
34525 #if !defined(USE_STRUCT_CONVERSION)
34526
34527 static NTSTATUS thunk64_vkDestroyDescriptorUpdateTemplateKHR(void *args)
34528 {
34529     struct vkDestroyDescriptorUpdateTemplateKHR_params *params = args;
34530
34531     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
34532
34533     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, params->descriptorUpdateTemplate, NULL);
34534     return STATUS_SUCCESS;
34535 }
34536
34537 #else /* USE_STRUCT_CONVERSION */
34538
34539 static NTSTATUS thunk32_vkDestroyDescriptorUpdateTemplateKHR(void *args)
34540 {
34541     struct
34542     {
34543         VkDevice device;
34544         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
34545         const VkAllocationCallbacks *pAllocator;
34546     } *params = args;
34547
34548     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
34549
34550     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, params->descriptorUpdateTemplate, NULL);
34551     return STATUS_SUCCESS;
34552 }
34553
34554 #endif /* USE_STRUCT_CONVERSION */
34555
34556 #if !defined(USE_STRUCT_CONVERSION)
34557
34558 static NTSTATUS thunk64_vkDestroyDevice(void *args)
34559 {
34560     struct vkDestroyDevice_params *params = args;
34561
34562     TRACE("%p, %p\n", params->device, params->pAllocator);
34563
34564     if (!params->device)
34565         return STATUS_SUCCESS;
34566
34567     wine_vkDestroyDevice(params->device, params->pAllocator);
34568     return STATUS_SUCCESS;
34569 }
34570
34571 #else /* USE_STRUCT_CONVERSION */
34572
34573 static NTSTATUS thunk32_vkDestroyDevice(void *args)
34574 {
34575     struct
34576     {
34577         VkDevice device;
34578         const VkAllocationCallbacks *pAllocator;
34579     } *params = args;
34580
34581     TRACE("%p, %p\n", params->device, params->pAllocator);
34582
34583     if (!params->device)
34584         return STATUS_SUCCESS;
34585
34586     wine_vkDestroyDevice(params->device, params->pAllocator);
34587     return STATUS_SUCCESS;
34588 }
34589
34590 #endif /* USE_STRUCT_CONVERSION */
34591
34592 #if !defined(USE_STRUCT_CONVERSION)
34593
34594 static NTSTATUS thunk64_vkDestroyEvent(void *args)
34595 {
34596     struct vkDestroyEvent_params *params = args;
34597
34598     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->event), params->pAllocator);
34599
34600     wine_device_from_handle(params->device)->funcs.p_vkDestroyEvent(wine_device_from_handle(params->device)->device, params->event, NULL);
34601     return STATUS_SUCCESS;
34602 }
34603
34604 #else /* USE_STRUCT_CONVERSION */
34605
34606 static NTSTATUS thunk32_vkDestroyEvent(void *args)
34607 {
34608     struct
34609     {
34610         VkDevice device;
34611         VkEvent DECLSPEC_ALIGN(8) event;
34612         const VkAllocationCallbacks *pAllocator;
34613     } *params = args;
34614
34615     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->event), params->pAllocator);
34616
34617     wine_device_from_handle(params->device)->funcs.p_vkDestroyEvent(wine_device_from_handle(params->device)->device, params->event, NULL);
34618     return STATUS_SUCCESS;
34619 }
34620
34621 #endif /* USE_STRUCT_CONVERSION */
34622
34623 #if !defined(USE_STRUCT_CONVERSION)
34624
34625 static NTSTATUS thunk64_vkDestroyFence(void *args)
34626 {
34627     struct vkDestroyFence_params *params = args;
34628
34629     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->fence), params->pAllocator);
34630
34631     wine_device_from_handle(params->device)->funcs.p_vkDestroyFence(wine_device_from_handle(params->device)->device, params->fence, NULL);
34632     return STATUS_SUCCESS;
34633 }
34634
34635 #else /* USE_STRUCT_CONVERSION */
34636
34637 static NTSTATUS thunk32_vkDestroyFence(void *args)
34638 {
34639     struct
34640     {
34641         VkDevice device;
34642         VkFence DECLSPEC_ALIGN(8) fence;
34643         const VkAllocationCallbacks *pAllocator;
34644     } *params = args;
34645
34646     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->fence), params->pAllocator);
34647
34648     wine_device_from_handle(params->device)->funcs.p_vkDestroyFence(wine_device_from_handle(params->device)->device, params->fence, NULL);
34649     return STATUS_SUCCESS;
34650 }
34651
34652 #endif /* USE_STRUCT_CONVERSION */
34653
34654 #if !defined(USE_STRUCT_CONVERSION)
34655
34656 static NTSTATUS thunk64_vkDestroyFramebuffer(void *args)
34657 {
34658     struct vkDestroyFramebuffer_params *params = args;
34659
34660     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pAllocator);
34661
34662     wine_device_from_handle(params->device)->funcs.p_vkDestroyFramebuffer(wine_device_from_handle(params->device)->device, params->framebuffer, NULL);
34663     return STATUS_SUCCESS;
34664 }
34665
34666 #else /* USE_STRUCT_CONVERSION */
34667
34668 static NTSTATUS thunk32_vkDestroyFramebuffer(void *args)
34669 {
34670     struct
34671     {
34672         VkDevice device;
34673         VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
34674         const VkAllocationCallbacks *pAllocator;
34675     } *params = args;
34676
34677     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pAllocator);
34678
34679     wine_device_from_handle(params->device)->funcs.p_vkDestroyFramebuffer(wine_device_from_handle(params->device)->device, params->framebuffer, NULL);
34680     return STATUS_SUCCESS;
34681 }
34682
34683 #endif /* USE_STRUCT_CONVERSION */
34684
34685 #if !defined(USE_STRUCT_CONVERSION)
34686
34687 static NTSTATUS thunk64_vkDestroyImage(void *args)
34688 {
34689     struct vkDestroyImage_params *params = args;
34690
34691     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pAllocator);
34692
34693     wine_device_from_handle(params->device)->funcs.p_vkDestroyImage(wine_device_from_handle(params->device)->device, params->image, NULL);
34694     return STATUS_SUCCESS;
34695 }
34696
34697 #else /* USE_STRUCT_CONVERSION */
34698
34699 static NTSTATUS thunk32_vkDestroyImage(void *args)
34700 {
34701     struct
34702     {
34703         VkDevice device;
34704         VkImage DECLSPEC_ALIGN(8) image;
34705         const VkAllocationCallbacks *pAllocator;
34706     } *params = args;
34707
34708     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pAllocator);
34709
34710     wine_device_from_handle(params->device)->funcs.p_vkDestroyImage(wine_device_from_handle(params->device)->device, params->image, NULL);
34711     return STATUS_SUCCESS;
34712 }
34713
34714 #endif /* USE_STRUCT_CONVERSION */
34715
34716 #if !defined(USE_STRUCT_CONVERSION)
34717
34718 static NTSTATUS thunk64_vkDestroyImageView(void *args)
34719 {
34720     struct vkDestroyImageView_params *params = args;
34721
34722     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pAllocator);
34723
34724     wine_device_from_handle(params->device)->funcs.p_vkDestroyImageView(wine_device_from_handle(params->device)->device, params->imageView, NULL);
34725     return STATUS_SUCCESS;
34726 }
34727
34728 #else /* USE_STRUCT_CONVERSION */
34729
34730 static NTSTATUS thunk32_vkDestroyImageView(void *args)
34731 {
34732     struct
34733     {
34734         VkDevice device;
34735         VkImageView DECLSPEC_ALIGN(8) imageView;
34736         const VkAllocationCallbacks *pAllocator;
34737     } *params = args;
34738
34739     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pAllocator);
34740
34741     wine_device_from_handle(params->device)->funcs.p_vkDestroyImageView(wine_device_from_handle(params->device)->device, params->imageView, NULL);
34742     return STATUS_SUCCESS;
34743 }
34744
34745 #endif /* USE_STRUCT_CONVERSION */
34746
34747 #if !defined(USE_STRUCT_CONVERSION)
34748
34749 static NTSTATUS thunk64_vkDestroyIndirectCommandsLayoutNV(void *args)
34750 {
34751     struct vkDestroyIndirectCommandsLayoutNV_params *params = args;
34752
34753     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->indirectCommandsLayout), params->pAllocator);
34754
34755     wine_device_from_handle(params->device)->funcs.p_vkDestroyIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, params->indirectCommandsLayout, NULL);
34756     return STATUS_SUCCESS;
34757 }
34758
34759 #else /* USE_STRUCT_CONVERSION */
34760
34761 static NTSTATUS thunk32_vkDestroyIndirectCommandsLayoutNV(void *args)
34762 {
34763     struct
34764     {
34765         VkDevice device;
34766         VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
34767         const VkAllocationCallbacks *pAllocator;
34768     } *params = args;
34769
34770     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->indirectCommandsLayout), params->pAllocator);
34771
34772     wine_device_from_handle(params->device)->funcs.p_vkDestroyIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, params->indirectCommandsLayout, NULL);
34773     return STATUS_SUCCESS;
34774 }
34775
34776 #endif /* USE_STRUCT_CONVERSION */
34777
34778 #if !defined(USE_STRUCT_CONVERSION)
34779
34780 static NTSTATUS thunk64_vkDestroyInstance(void *args)
34781 {
34782     struct vkDestroyInstance_params *params = args;
34783
34784     TRACE("%p, %p\n", params->instance, params->pAllocator);
34785
34786     if (!params->instance)
34787         return STATUS_SUCCESS;
34788
34789     wine_vkDestroyInstance(params->instance, params->pAllocator);
34790     return STATUS_SUCCESS;
34791 }
34792
34793 #else /* USE_STRUCT_CONVERSION */
34794
34795 static NTSTATUS thunk32_vkDestroyInstance(void *args)
34796 {
34797     struct
34798     {
34799         VkInstance instance;
34800         const VkAllocationCallbacks *pAllocator;
34801     } *params = args;
34802
34803     TRACE("%p, %p\n", params->instance, params->pAllocator);
34804
34805     if (!params->instance)
34806         return STATUS_SUCCESS;
34807
34808     wine_vkDestroyInstance(params->instance, params->pAllocator);
34809     return STATUS_SUCCESS;
34810 }
34811
34812 #endif /* USE_STRUCT_CONVERSION */
34813
34814 #if !defined(USE_STRUCT_CONVERSION)
34815
34816 static NTSTATUS thunk64_vkDestroyMicromapEXT(void *args)
34817 {
34818     struct vkDestroyMicromapEXT_params *params = args;
34819
34820     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->micromap), params->pAllocator);
34821
34822     wine_device_from_handle(params->device)->funcs.p_vkDestroyMicromapEXT(wine_device_from_handle(params->device)->device, params->micromap, NULL);
34823     return STATUS_SUCCESS;
34824 }
34825
34826 #else /* USE_STRUCT_CONVERSION */
34827
34828 static NTSTATUS thunk32_vkDestroyMicromapEXT(void *args)
34829 {
34830     struct
34831     {
34832         VkDevice device;
34833         VkMicromapEXT DECLSPEC_ALIGN(8) micromap;
34834         const VkAllocationCallbacks *pAllocator;
34835     } *params = args;
34836
34837     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->micromap), params->pAllocator);
34838
34839     wine_device_from_handle(params->device)->funcs.p_vkDestroyMicromapEXT(wine_device_from_handle(params->device)->device, params->micromap, NULL);
34840     return STATUS_SUCCESS;
34841 }
34842
34843 #endif /* USE_STRUCT_CONVERSION */
34844
34845 #if !defined(USE_STRUCT_CONVERSION)
34846
34847 static NTSTATUS thunk64_vkDestroyOpticalFlowSessionNV(void *args)
34848 {
34849     struct vkDestroyOpticalFlowSessionNV_params *params = args;
34850
34851     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->session), params->pAllocator);
34852
34853     wine_device_from_handle(params->device)->funcs.p_vkDestroyOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->session, NULL);
34854     return STATUS_SUCCESS;
34855 }
34856
34857 #else /* USE_STRUCT_CONVERSION */
34858
34859 static NTSTATUS thunk32_vkDestroyOpticalFlowSessionNV(void *args)
34860 {
34861     struct
34862     {
34863         VkDevice device;
34864         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
34865         const VkAllocationCallbacks *pAllocator;
34866     } *params = args;
34867
34868     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->session), params->pAllocator);
34869
34870     wine_device_from_handle(params->device)->funcs.p_vkDestroyOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->session, NULL);
34871     return STATUS_SUCCESS;
34872 }
34873
34874 #endif /* USE_STRUCT_CONVERSION */
34875
34876 #if !defined(USE_STRUCT_CONVERSION)
34877
34878 static NTSTATUS thunk64_vkDestroyPipeline(void *args)
34879 {
34880     struct vkDestroyPipeline_params *params = args;
34881
34882     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->pAllocator);
34883
34884     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipeline(wine_device_from_handle(params->device)->device, params->pipeline, NULL);
34885     return STATUS_SUCCESS;
34886 }
34887
34888 #else /* USE_STRUCT_CONVERSION */
34889
34890 static NTSTATUS thunk32_vkDestroyPipeline(void *args)
34891 {
34892     struct
34893     {
34894         VkDevice device;
34895         VkPipeline DECLSPEC_ALIGN(8) pipeline;
34896         const VkAllocationCallbacks *pAllocator;
34897     } *params = args;
34898
34899     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->pAllocator);
34900
34901     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipeline(wine_device_from_handle(params->device)->device, params->pipeline, NULL);
34902     return STATUS_SUCCESS;
34903 }
34904
34905 #endif /* USE_STRUCT_CONVERSION */
34906
34907 #if !defined(USE_STRUCT_CONVERSION)
34908
34909 static NTSTATUS thunk64_vkDestroyPipelineCache(void *args)
34910 {
34911     struct vkDestroyPipelineCache_params *params = args;
34912
34913     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pAllocator);
34914
34915     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipelineCache(wine_device_from_handle(params->device)->device, params->pipelineCache, NULL);
34916     return STATUS_SUCCESS;
34917 }
34918
34919 #else /* USE_STRUCT_CONVERSION */
34920
34921 static NTSTATUS thunk32_vkDestroyPipelineCache(void *args)
34922 {
34923     struct
34924     {
34925         VkDevice device;
34926         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
34927         const VkAllocationCallbacks *pAllocator;
34928     } *params = args;
34929
34930     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pAllocator);
34931
34932     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipelineCache(wine_device_from_handle(params->device)->device, params->pipelineCache, NULL);
34933     return STATUS_SUCCESS;
34934 }
34935
34936 #endif /* USE_STRUCT_CONVERSION */
34937
34938 #if !defined(USE_STRUCT_CONVERSION)
34939
34940 static NTSTATUS thunk64_vkDestroyPipelineLayout(void *args)
34941 {
34942     struct vkDestroyPipelineLayout_params *params = args;
34943
34944     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipelineLayout), params->pAllocator);
34945
34946     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipelineLayout(wine_device_from_handle(params->device)->device, params->pipelineLayout, NULL);
34947     return STATUS_SUCCESS;
34948 }
34949
34950 #else /* USE_STRUCT_CONVERSION */
34951
34952 static NTSTATUS thunk32_vkDestroyPipelineLayout(void *args)
34953 {
34954     struct
34955     {
34956         VkDevice device;
34957         VkPipelineLayout DECLSPEC_ALIGN(8) pipelineLayout;
34958         const VkAllocationCallbacks *pAllocator;
34959     } *params = args;
34960
34961     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipelineLayout), params->pAllocator);
34962
34963     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipelineLayout(wine_device_from_handle(params->device)->device, params->pipelineLayout, NULL);
34964     return STATUS_SUCCESS;
34965 }
34966
34967 #endif /* USE_STRUCT_CONVERSION */
34968
34969 #if !defined(USE_STRUCT_CONVERSION)
34970
34971 static NTSTATUS thunk64_vkDestroyPrivateDataSlot(void *args)
34972 {
34973     struct vkDestroyPrivateDataSlot_params *params = args;
34974
34975     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
34976
34977     wine_device_from_handle(params->device)->funcs.p_vkDestroyPrivateDataSlot(wine_device_from_handle(params->device)->device, params->privateDataSlot, NULL);
34978     return STATUS_SUCCESS;
34979 }
34980
34981 #else /* USE_STRUCT_CONVERSION */
34982
34983 static NTSTATUS thunk32_vkDestroyPrivateDataSlot(void *args)
34984 {
34985     struct
34986     {
34987         VkDevice device;
34988         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
34989         const VkAllocationCallbacks *pAllocator;
34990     } *params = args;
34991
34992     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
34993
34994     wine_device_from_handle(params->device)->funcs.p_vkDestroyPrivateDataSlot(wine_device_from_handle(params->device)->device, params->privateDataSlot, NULL);
34995     return STATUS_SUCCESS;
34996 }
34997
34998 #endif /* USE_STRUCT_CONVERSION */
34999
35000 #if !defined(USE_STRUCT_CONVERSION)
35001
35002 static NTSTATUS thunk64_vkDestroyPrivateDataSlotEXT(void *args)
35003 {
35004     struct vkDestroyPrivateDataSlotEXT_params *params = args;
35005
35006     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
35007
35008     wine_device_from_handle(params->device)->funcs.p_vkDestroyPrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->privateDataSlot, NULL);
35009     return STATUS_SUCCESS;
35010 }
35011
35012 #else /* USE_STRUCT_CONVERSION */
35013
35014 static NTSTATUS thunk32_vkDestroyPrivateDataSlotEXT(void *args)
35015 {
35016     struct
35017     {
35018         VkDevice device;
35019         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
35020         const VkAllocationCallbacks *pAllocator;
35021     } *params = args;
35022
35023     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
35024
35025     wine_device_from_handle(params->device)->funcs.p_vkDestroyPrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->privateDataSlot, NULL);
35026     return STATUS_SUCCESS;
35027 }
35028
35029 #endif /* USE_STRUCT_CONVERSION */
35030
35031 #if !defined(USE_STRUCT_CONVERSION)
35032
35033 static NTSTATUS thunk64_vkDestroyQueryPool(void *args)
35034 {
35035     struct vkDestroyQueryPool_params *params = args;
35036
35037     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->queryPool), params->pAllocator);
35038
35039     wine_device_from_handle(params->device)->funcs.p_vkDestroyQueryPool(wine_device_from_handle(params->device)->device, params->queryPool, NULL);
35040     return STATUS_SUCCESS;
35041 }
35042
35043 #else /* USE_STRUCT_CONVERSION */
35044
35045 static NTSTATUS thunk32_vkDestroyQueryPool(void *args)
35046 {
35047     struct
35048     {
35049         VkDevice device;
35050         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
35051         const VkAllocationCallbacks *pAllocator;
35052     } *params = args;
35053
35054     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->queryPool), params->pAllocator);
35055
35056     wine_device_from_handle(params->device)->funcs.p_vkDestroyQueryPool(wine_device_from_handle(params->device)->device, params->queryPool, NULL);
35057     return STATUS_SUCCESS;
35058 }
35059
35060 #endif /* USE_STRUCT_CONVERSION */
35061
35062 #if !defined(USE_STRUCT_CONVERSION)
35063
35064 static NTSTATUS thunk64_vkDestroyRenderPass(void *args)
35065 {
35066     struct vkDestroyRenderPass_params *params = args;
35067
35068     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pAllocator);
35069
35070     wine_device_from_handle(params->device)->funcs.p_vkDestroyRenderPass(wine_device_from_handle(params->device)->device, params->renderPass, NULL);
35071     return STATUS_SUCCESS;
35072 }
35073
35074 #else /* USE_STRUCT_CONVERSION */
35075
35076 static NTSTATUS thunk32_vkDestroyRenderPass(void *args)
35077 {
35078     struct
35079     {
35080         VkDevice device;
35081         VkRenderPass DECLSPEC_ALIGN(8) renderPass;
35082         const VkAllocationCallbacks *pAllocator;
35083     } *params = args;
35084
35085     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pAllocator);
35086
35087     wine_device_from_handle(params->device)->funcs.p_vkDestroyRenderPass(wine_device_from_handle(params->device)->device, params->renderPass, NULL);
35088     return STATUS_SUCCESS;
35089 }
35090
35091 #endif /* USE_STRUCT_CONVERSION */
35092
35093 #if !defined(USE_STRUCT_CONVERSION)
35094
35095 static NTSTATUS thunk64_vkDestroySampler(void *args)
35096 {
35097     struct vkDestroySampler_params *params = args;
35098
35099     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->sampler), params->pAllocator);
35100
35101     wine_device_from_handle(params->device)->funcs.p_vkDestroySampler(wine_device_from_handle(params->device)->device, params->sampler, NULL);
35102     return STATUS_SUCCESS;
35103 }
35104
35105 #else /* USE_STRUCT_CONVERSION */
35106
35107 static NTSTATUS thunk32_vkDestroySampler(void *args)
35108 {
35109     struct
35110     {
35111         VkDevice device;
35112         VkSampler DECLSPEC_ALIGN(8) sampler;
35113         const VkAllocationCallbacks *pAllocator;
35114     } *params = args;
35115
35116     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->sampler), params->pAllocator);
35117
35118     wine_device_from_handle(params->device)->funcs.p_vkDestroySampler(wine_device_from_handle(params->device)->device, params->sampler, NULL);
35119     return STATUS_SUCCESS;
35120 }
35121
35122 #endif /* USE_STRUCT_CONVERSION */
35123
35124 #if !defined(USE_STRUCT_CONVERSION)
35125
35126 static NTSTATUS thunk64_vkDestroySamplerYcbcrConversion(void *args)
35127 {
35128     struct vkDestroySamplerYcbcrConversion_params *params = args;
35129
35130     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
35131
35132     wine_device_from_handle(params->device)->funcs.p_vkDestroySamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->ycbcrConversion, NULL);
35133     return STATUS_SUCCESS;
35134 }
35135
35136 #else /* USE_STRUCT_CONVERSION */
35137
35138 static NTSTATUS thunk32_vkDestroySamplerYcbcrConversion(void *args)
35139 {
35140     struct
35141     {
35142         VkDevice device;
35143         VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) ycbcrConversion;
35144         const VkAllocationCallbacks *pAllocator;
35145     } *params = args;
35146
35147     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
35148
35149     wine_device_from_handle(params->device)->funcs.p_vkDestroySamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->ycbcrConversion, NULL);
35150     return STATUS_SUCCESS;
35151 }
35152
35153 #endif /* USE_STRUCT_CONVERSION */
35154
35155 #if !defined(USE_STRUCT_CONVERSION)
35156
35157 static NTSTATUS thunk64_vkDestroySamplerYcbcrConversionKHR(void *args)
35158 {
35159     struct vkDestroySamplerYcbcrConversionKHR_params *params = args;
35160
35161     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
35162
35163     wine_device_from_handle(params->device)->funcs.p_vkDestroySamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->ycbcrConversion, NULL);
35164     return STATUS_SUCCESS;
35165 }
35166
35167 #else /* USE_STRUCT_CONVERSION */
35168
35169 static NTSTATUS thunk32_vkDestroySamplerYcbcrConversionKHR(void *args)
35170 {
35171     struct
35172     {
35173         VkDevice device;
35174         VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) ycbcrConversion;
35175         const VkAllocationCallbacks *pAllocator;
35176     } *params = args;
35177
35178     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
35179
35180     wine_device_from_handle(params->device)->funcs.p_vkDestroySamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->ycbcrConversion, NULL);
35181     return STATUS_SUCCESS;
35182 }
35183
35184 #endif /* USE_STRUCT_CONVERSION */
35185
35186 #if !defined(USE_STRUCT_CONVERSION)
35187
35188 static NTSTATUS thunk64_vkDestroySemaphore(void *args)
35189 {
35190     struct vkDestroySemaphore_params *params = args;
35191
35192     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pAllocator);
35193
35194     wine_device_from_handle(params->device)->funcs.p_vkDestroySemaphore(wine_device_from_handle(params->device)->device, params->semaphore, NULL);
35195     return STATUS_SUCCESS;
35196 }
35197
35198 #else /* USE_STRUCT_CONVERSION */
35199
35200 static NTSTATUS thunk32_vkDestroySemaphore(void *args)
35201 {
35202     struct
35203     {
35204         VkDevice device;
35205         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
35206         const VkAllocationCallbacks *pAllocator;
35207     } *params = args;
35208
35209     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pAllocator);
35210
35211     wine_device_from_handle(params->device)->funcs.p_vkDestroySemaphore(wine_device_from_handle(params->device)->device, params->semaphore, NULL);
35212     return STATUS_SUCCESS;
35213 }
35214
35215 #endif /* USE_STRUCT_CONVERSION */
35216
35217 #if !defined(USE_STRUCT_CONVERSION)
35218
35219 static NTSTATUS thunk64_vkDestroyShaderModule(void *args)
35220 {
35221     struct vkDestroyShaderModule_params *params = args;
35222
35223     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pAllocator);
35224
35225     wine_device_from_handle(params->device)->funcs.p_vkDestroyShaderModule(wine_device_from_handle(params->device)->device, params->shaderModule, NULL);
35226     return STATUS_SUCCESS;
35227 }
35228
35229 #else /* USE_STRUCT_CONVERSION */
35230
35231 static NTSTATUS thunk32_vkDestroyShaderModule(void *args)
35232 {
35233     struct
35234     {
35235         VkDevice device;
35236         VkShaderModule DECLSPEC_ALIGN(8) shaderModule;
35237         const VkAllocationCallbacks *pAllocator;
35238     } *params = args;
35239
35240     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pAllocator);
35241
35242     wine_device_from_handle(params->device)->funcs.p_vkDestroyShaderModule(wine_device_from_handle(params->device)->device, params->shaderModule, NULL);
35243     return STATUS_SUCCESS;
35244 }
35245
35246 #endif /* USE_STRUCT_CONVERSION */
35247
35248 #if !defined(USE_STRUCT_CONVERSION)
35249
35250 static NTSTATUS thunk64_vkDestroySurfaceKHR(void *args)
35251 {
35252     struct vkDestroySurfaceKHR_params *params = args;
35253
35254     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->surface), params->pAllocator);
35255
35256     wine_vkDestroySurfaceKHR(params->instance, params->surface, params->pAllocator);
35257     return STATUS_SUCCESS;
35258 }
35259
35260 #else /* USE_STRUCT_CONVERSION */
35261
35262 static NTSTATUS thunk32_vkDestroySurfaceKHR(void *args)
35263 {
35264     struct
35265     {
35266         VkInstance instance;
35267         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
35268         const VkAllocationCallbacks *pAllocator;
35269     } *params = args;
35270
35271     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->surface), params->pAllocator);
35272
35273     wine_vkDestroySurfaceKHR(params->instance, params->surface, params->pAllocator);
35274     return STATUS_SUCCESS;
35275 }
35276
35277 #endif /* USE_STRUCT_CONVERSION */
35278
35279 #if !defined(USE_STRUCT_CONVERSION)
35280
35281 static NTSTATUS thunk64_vkDestroySwapchainKHR(void *args)
35282 {
35283     struct vkDestroySwapchainKHR_params *params = args;
35284
35285     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pAllocator);
35286
35287     wine_device_from_handle(params->device)->funcs.p_vkDestroySwapchainKHR(wine_device_from_handle(params->device)->device, params->swapchain, NULL);
35288     return STATUS_SUCCESS;
35289 }
35290
35291 #else /* USE_STRUCT_CONVERSION */
35292
35293 static NTSTATUS thunk32_vkDestroySwapchainKHR(void *args)
35294 {
35295     struct
35296     {
35297         VkDevice device;
35298         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
35299         const VkAllocationCallbacks *pAllocator;
35300     } *params = args;
35301
35302     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pAllocator);
35303
35304     wine_device_from_handle(params->device)->funcs.p_vkDestroySwapchainKHR(wine_device_from_handle(params->device)->device, params->swapchain, NULL);
35305     return STATUS_SUCCESS;
35306 }
35307
35308 #endif /* USE_STRUCT_CONVERSION */
35309
35310 #if !defined(USE_STRUCT_CONVERSION)
35311
35312 static NTSTATUS thunk64_vkDestroyValidationCacheEXT(void *args)
35313 {
35314     struct vkDestroyValidationCacheEXT_params *params = args;
35315
35316     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pAllocator);
35317
35318     wine_device_from_handle(params->device)->funcs.p_vkDestroyValidationCacheEXT(wine_device_from_handle(params->device)->device, params->validationCache, NULL);
35319     return STATUS_SUCCESS;
35320 }
35321
35322 #else /* USE_STRUCT_CONVERSION */
35323
35324 static NTSTATUS thunk32_vkDestroyValidationCacheEXT(void *args)
35325 {
35326     struct
35327     {
35328         VkDevice device;
35329         VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
35330         const VkAllocationCallbacks *pAllocator;
35331     } *params = args;
35332
35333     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pAllocator);
35334
35335     wine_device_from_handle(params->device)->funcs.p_vkDestroyValidationCacheEXT(wine_device_from_handle(params->device)->device, params->validationCache, NULL);
35336     return STATUS_SUCCESS;
35337 }
35338
35339 #endif /* USE_STRUCT_CONVERSION */
35340
35341 #if !defined(USE_STRUCT_CONVERSION)
35342
35343 static NTSTATUS thunk64_vkDeviceWaitIdle(void *args)
35344 {
35345     struct vkDeviceWaitIdle_params *params = args;
35346
35347     TRACE("%p\n", params->device);
35348
35349     params->result = wine_device_from_handle(params->device)->funcs.p_vkDeviceWaitIdle(wine_device_from_handle(params->device)->device);
35350     return STATUS_SUCCESS;
35351 }
35352
35353 #else /* USE_STRUCT_CONVERSION */
35354
35355 static NTSTATUS thunk32_vkDeviceWaitIdle(void *args)
35356 {
35357     struct
35358     {
35359         VkDevice device;
35360         VkResult result;
35361     } *params = args;
35362
35363     TRACE("%p\n", params->device);
35364
35365     params->result = wine_device_from_handle(params->device)->funcs.p_vkDeviceWaitIdle(wine_device_from_handle(params->device)->device);
35366     return STATUS_SUCCESS;
35367 }
35368
35369 #endif /* USE_STRUCT_CONVERSION */
35370
35371 #if !defined(USE_STRUCT_CONVERSION)
35372
35373 static NTSTATUS thunk64_vkEndCommandBuffer(void *args)
35374 {
35375     struct vkEndCommandBuffer_params *params = args;
35376
35377     TRACE("%p\n", params->commandBuffer);
35378
35379     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkEndCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
35380     return STATUS_SUCCESS;
35381 }
35382
35383 #else /* USE_STRUCT_CONVERSION */
35384
35385 static NTSTATUS thunk32_vkEndCommandBuffer(void *args)
35386 {
35387     struct
35388     {
35389         VkCommandBuffer commandBuffer;
35390         VkResult result;
35391     } *params = args;
35392
35393     TRACE("%p\n", params->commandBuffer);
35394
35395     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkEndCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
35396     return STATUS_SUCCESS;
35397 }
35398
35399 #endif /* USE_STRUCT_CONVERSION */
35400
35401 #if !defined(USE_STRUCT_CONVERSION)
35402
35403 static NTSTATUS thunk64_vkEnumerateDeviceExtensionProperties(void *args)
35404 {
35405     struct vkEnumerateDeviceExtensionProperties_params *params = args;
35406
35407     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
35408
35409     params->result = wine_vkEnumerateDeviceExtensionProperties(params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
35410     return STATUS_SUCCESS;
35411 }
35412
35413 #else /* USE_STRUCT_CONVERSION */
35414
35415 static NTSTATUS thunk32_vkEnumerateDeviceExtensionProperties(void *args)
35416 {
35417     struct
35418     {
35419         VkPhysicalDevice physicalDevice;
35420         const char *pLayerName;
35421         uint32_t *pPropertyCount;
35422         VkExtensionProperties *pProperties;
35423         VkResult result;
35424     } *params = args;
35425
35426     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
35427
35428     params->result = wine_vkEnumerateDeviceExtensionProperties(params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
35429     return STATUS_SUCCESS;
35430 }
35431
35432 #endif /* USE_STRUCT_CONVERSION */
35433
35434 #if !defined(USE_STRUCT_CONVERSION)
35435
35436 static NTSTATUS thunk64_vkEnumerateDeviceLayerProperties(void *args)
35437 {
35438     struct vkEnumerateDeviceLayerProperties_params *params = args;
35439
35440     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
35441
35442     params->result = wine_vkEnumerateDeviceLayerProperties(params->physicalDevice, params->pPropertyCount, params->pProperties);
35443     return STATUS_SUCCESS;
35444 }
35445
35446 #else /* USE_STRUCT_CONVERSION */
35447
35448 static NTSTATUS thunk32_vkEnumerateDeviceLayerProperties(void *args)
35449 {
35450     struct
35451     {
35452         VkPhysicalDevice physicalDevice;
35453         uint32_t *pPropertyCount;
35454         VkLayerProperties *pProperties;
35455         VkResult result;
35456     } *params = args;
35457
35458     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
35459
35460     params->result = wine_vkEnumerateDeviceLayerProperties(params->physicalDevice, params->pPropertyCount, params->pProperties);
35461     return STATUS_SUCCESS;
35462 }
35463
35464 #endif /* USE_STRUCT_CONVERSION */
35465
35466 #if !defined(USE_STRUCT_CONVERSION)
35467
35468 static NTSTATUS thunk64_vkEnumerateInstanceExtensionProperties(void *args)
35469 {
35470     struct vkEnumerateInstanceExtensionProperties_params *params = args;
35471
35472     TRACE("%p, %p, %p\n", params->pLayerName, params->pPropertyCount, params->pProperties);
35473
35474     params->result = wine_vkEnumerateInstanceExtensionProperties(params->pLayerName, params->pPropertyCount, params->pProperties);
35475     return STATUS_SUCCESS;
35476 }
35477
35478 #else /* USE_STRUCT_CONVERSION */
35479
35480 static NTSTATUS thunk32_vkEnumerateInstanceExtensionProperties(void *args)
35481 {
35482     struct
35483     {
35484         const char *pLayerName;
35485         uint32_t *pPropertyCount;
35486         VkExtensionProperties *pProperties;
35487         VkResult result;
35488     } *params = args;
35489
35490     TRACE("%p, %p, %p\n", params->pLayerName, params->pPropertyCount, params->pProperties);
35491
35492     params->result = wine_vkEnumerateInstanceExtensionProperties(params->pLayerName, params->pPropertyCount, params->pProperties);
35493     return STATUS_SUCCESS;
35494 }
35495
35496 #endif /* USE_STRUCT_CONVERSION */
35497
35498 #if !defined(USE_STRUCT_CONVERSION)
35499
35500 static NTSTATUS thunk64_vkEnumerateInstanceVersion(void *args)
35501 {
35502     struct vkEnumerateInstanceVersion_params *params = args;
35503
35504     TRACE("%p\n", params->pApiVersion);
35505
35506     params->result = wine_vkEnumerateInstanceVersion(params->pApiVersion);
35507     return STATUS_SUCCESS;
35508 }
35509
35510 #else /* USE_STRUCT_CONVERSION */
35511
35512 static NTSTATUS thunk32_vkEnumerateInstanceVersion(void *args)
35513 {
35514     struct
35515     {
35516         uint32_t *pApiVersion;
35517         VkResult result;
35518     } *params = args;
35519
35520     TRACE("%p\n", params->pApiVersion);
35521
35522     params->result = wine_vkEnumerateInstanceVersion(params->pApiVersion);
35523     return STATUS_SUCCESS;
35524 }
35525
35526 #endif /* USE_STRUCT_CONVERSION */
35527
35528 #if !defined(USE_STRUCT_CONVERSION)
35529
35530 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceGroups(void *args)
35531 {
35532     struct vkEnumeratePhysicalDeviceGroups_params *params = args;
35533
35534     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
35535
35536     params->result = wine_vkEnumeratePhysicalDeviceGroups(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
35537     return STATUS_SUCCESS;
35538 }
35539
35540 #else /* USE_STRUCT_CONVERSION */
35541
35542 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceGroups(void *args)
35543 {
35544     struct
35545     {
35546         VkInstance instance;
35547         uint32_t *pPhysicalDeviceGroupCount;
35548         VkPhysicalDeviceGroupProperties32 *pPhysicalDeviceGroupProperties;
35549         VkResult result;
35550     } *params = args;
35551     VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties_host;
35552     struct conversion_context ctx;
35553
35554     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
35555
35556     init_conversion_context(&ctx);
35557     pPhysicalDeviceGroupProperties_host = convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(&ctx, params->pPhysicalDeviceGroupProperties, *params->pPhysicalDeviceGroupCount);
35558     params->result = wine_vkEnumeratePhysicalDeviceGroups(params->instance, params->pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties_host);
35559     convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(pPhysicalDeviceGroupProperties_host, params->pPhysicalDeviceGroupProperties, *params->pPhysicalDeviceGroupCount);
35560     free_conversion_context(&ctx);
35561     return STATUS_SUCCESS;
35562 }
35563
35564 #endif /* USE_STRUCT_CONVERSION */
35565
35566 #if !defined(USE_STRUCT_CONVERSION)
35567
35568 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceGroupsKHR(void *args)
35569 {
35570     struct vkEnumeratePhysicalDeviceGroupsKHR_params *params = args;
35571
35572     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
35573
35574     params->result = wine_vkEnumeratePhysicalDeviceGroupsKHR(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
35575     return STATUS_SUCCESS;
35576 }
35577
35578 #else /* USE_STRUCT_CONVERSION */
35579
35580 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceGroupsKHR(void *args)
35581 {
35582     struct
35583     {
35584         VkInstance instance;
35585         uint32_t *pPhysicalDeviceGroupCount;
35586         VkPhysicalDeviceGroupProperties32 *pPhysicalDeviceGroupProperties;
35587         VkResult result;
35588     } *params = args;
35589     VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties_host;
35590     struct conversion_context ctx;
35591
35592     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
35593
35594     init_conversion_context(&ctx);
35595     pPhysicalDeviceGroupProperties_host = convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(&ctx, params->pPhysicalDeviceGroupProperties, *params->pPhysicalDeviceGroupCount);
35596     params->result = wine_vkEnumeratePhysicalDeviceGroupsKHR(params->instance, params->pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties_host);
35597     convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(pPhysicalDeviceGroupProperties_host, params->pPhysicalDeviceGroupProperties, *params->pPhysicalDeviceGroupCount);
35598     free_conversion_context(&ctx);
35599     return STATUS_SUCCESS;
35600 }
35601
35602 #endif /* USE_STRUCT_CONVERSION */
35603
35604 #if !defined(USE_STRUCT_CONVERSION)
35605
35606 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(void *args)
35607 {
35608     struct vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_params *params = args;
35609
35610     TRACE("%p, %u, %p, %p, %p\n", params->physicalDevice, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);
35611
35612     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);
35613     return STATUS_SUCCESS;
35614 }
35615
35616 #else /* USE_STRUCT_CONVERSION */
35617
35618 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(void *args)
35619 {
35620     struct
35621     {
35622         VkPhysicalDevice physicalDevice;
35623         uint32_t queueFamilyIndex;
35624         uint32_t *pCounterCount;
35625         VkPerformanceCounterKHR32 *pCounters;
35626         VkPerformanceCounterDescriptionKHR32 *pCounterDescriptions;
35627         VkResult result;
35628     } *params = args;
35629     VkPerformanceCounterKHR *pCounters_host;
35630     VkPerformanceCounterDescriptionKHR *pCounterDescriptions_host;
35631     struct conversion_context ctx;
35632
35633     TRACE("%p, %u, %p, %p, %p\n", params->physicalDevice, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);
35634
35635     init_conversion_context(&ctx);
35636     pCounters_host = convert_VkPerformanceCounterKHR_array_win32_to_host(&ctx, params->pCounters, *params->pCounterCount);
35637     pCounterDescriptions_host = convert_VkPerformanceCounterDescriptionKHR_array_win32_to_host(&ctx, params->pCounterDescriptions, *params->pCounterCount);
35638     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex, params->pCounterCount, pCounters_host, pCounterDescriptions_host);
35639     convert_VkPerformanceCounterKHR_array_host_to_win32(pCounters_host, params->pCounters, *params->pCounterCount);
35640     convert_VkPerformanceCounterDescriptionKHR_array_host_to_win32(pCounterDescriptions_host, params->pCounterDescriptions, *params->pCounterCount);
35641     free_conversion_context(&ctx);
35642     return STATUS_SUCCESS;
35643 }
35644
35645 #endif /* USE_STRUCT_CONVERSION */
35646
35647 #if !defined(USE_STRUCT_CONVERSION)
35648
35649 static NTSTATUS thunk64_vkEnumeratePhysicalDevices(void *args)
35650 {
35651     struct vkEnumeratePhysicalDevices_params *params = args;
35652
35653     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
35654
35655     params->result = wine_vkEnumeratePhysicalDevices(params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
35656     return STATUS_SUCCESS;
35657 }
35658
35659 #else /* USE_STRUCT_CONVERSION */
35660
35661 static NTSTATUS thunk32_vkEnumeratePhysicalDevices(void *args)
35662 {
35663     struct
35664     {
35665         VkInstance instance;
35666         uint32_t *pPhysicalDeviceCount;
35667         VkPhysicalDevice *pPhysicalDevices;
35668         VkResult result;
35669     } *params = args;
35670
35671     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
35672
35673     params->result = wine_vkEnumeratePhysicalDevices(params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
35674     return STATUS_SUCCESS;
35675 }
35676
35677 #endif /* USE_STRUCT_CONVERSION */
35678
35679 #if !defined(USE_STRUCT_CONVERSION)
35680
35681 static NTSTATUS thunk64_vkFlushMappedMemoryRanges(void *args)
35682 {
35683     struct vkFlushMappedMemoryRanges_params *params = args;
35684
35685     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
35686
35687     params->result = wine_device_from_handle(params->device)->funcs.p_vkFlushMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, params->pMemoryRanges);
35688     return STATUS_SUCCESS;
35689 }
35690
35691 #else /* USE_STRUCT_CONVERSION */
35692
35693 static NTSTATUS thunk32_vkFlushMappedMemoryRanges(void *args)
35694 {
35695     struct
35696     {
35697         VkDevice device;
35698         uint32_t memoryRangeCount;
35699         const VkMappedMemoryRange32 *pMemoryRanges;
35700         VkResult result;
35701     } *params = args;
35702     const VkMappedMemoryRange *pMemoryRanges_host;
35703     struct conversion_context ctx;
35704
35705     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
35706
35707     init_conversion_context(&ctx);
35708     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win32_to_host(&ctx, params->pMemoryRanges, params->memoryRangeCount);
35709     params->result = wine_device_from_handle(params->device)->funcs.p_vkFlushMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, pMemoryRanges_host);
35710     free_conversion_context(&ctx);
35711     return STATUS_SUCCESS;
35712 }
35713
35714 #endif /* USE_STRUCT_CONVERSION */
35715
35716 #if !defined(USE_STRUCT_CONVERSION)
35717
35718 static NTSTATUS thunk64_vkFreeCommandBuffers(void *args)
35719 {
35720     struct vkFreeCommandBuffers_params *params = args;
35721
35722     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->commandPool), params->commandBufferCount, params->pCommandBuffers);
35723
35724     wine_vkFreeCommandBuffers(params->device, params->commandPool, params->commandBufferCount, params->pCommandBuffers);
35725     return STATUS_SUCCESS;
35726 }
35727
35728 #else /* USE_STRUCT_CONVERSION */
35729
35730 static NTSTATUS thunk32_vkFreeCommandBuffers(void *args)
35731 {
35732     struct
35733     {
35734         VkDevice device;
35735         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
35736         uint32_t commandBufferCount;
35737         const VkCommandBuffer *pCommandBuffers;
35738     } *params = args;
35739
35740     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->commandPool), params->commandBufferCount, params->pCommandBuffers);
35741
35742     wine_vkFreeCommandBuffers(params->device, params->commandPool, params->commandBufferCount, params->pCommandBuffers);
35743     return STATUS_SUCCESS;
35744 }
35745
35746 #endif /* USE_STRUCT_CONVERSION */
35747
35748 #if !defined(USE_STRUCT_CONVERSION)
35749
35750 static NTSTATUS thunk64_vkFreeDescriptorSets(void *args)
35751 {
35752     struct vkFreeDescriptorSets_params *params = args;
35753
35754     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->descriptorSetCount, params->pDescriptorSets);
35755
35756     params->result = wine_device_from_handle(params->device)->funcs.p_vkFreeDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorPool, params->descriptorSetCount, params->pDescriptorSets);
35757     return STATUS_SUCCESS;
35758 }
35759
35760 #else /* USE_STRUCT_CONVERSION */
35761
35762 static NTSTATUS thunk32_vkFreeDescriptorSets(void *args)
35763 {
35764     struct
35765     {
35766         VkDevice device;
35767         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
35768         uint32_t descriptorSetCount;
35769         const VkDescriptorSet *pDescriptorSets;
35770         VkResult result;
35771     } *params = args;
35772
35773     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->descriptorSetCount, params->pDescriptorSets);
35774
35775     params->result = wine_device_from_handle(params->device)->funcs.p_vkFreeDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorPool, params->descriptorSetCount, params->pDescriptorSets);
35776     return STATUS_SUCCESS;
35777 }
35778
35779 #endif /* USE_STRUCT_CONVERSION */
35780
35781 #if !defined(USE_STRUCT_CONVERSION)
35782
35783 static NTSTATUS thunk64_vkFreeMemory(void *args)
35784 {
35785     struct vkFreeMemory_params *params = args;
35786
35787     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->memory), params->pAllocator);
35788
35789     wine_device_from_handle(params->device)->funcs.p_vkFreeMemory(wine_device_from_handle(params->device)->device, params->memory, NULL);
35790     return STATUS_SUCCESS;
35791 }
35792
35793 #else /* USE_STRUCT_CONVERSION */
35794
35795 static NTSTATUS thunk32_vkFreeMemory(void *args)
35796 {
35797     struct
35798     {
35799         VkDevice device;
35800         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
35801         const VkAllocationCallbacks *pAllocator;
35802     } *params = args;
35803
35804     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->memory), params->pAllocator);
35805
35806     wine_device_from_handle(params->device)->funcs.p_vkFreeMemory(wine_device_from_handle(params->device)->device, params->memory, NULL);
35807     return STATUS_SUCCESS;
35808 }
35809
35810 #endif /* USE_STRUCT_CONVERSION */
35811
35812 #if !defined(USE_STRUCT_CONVERSION)
35813
35814 static NTSTATUS thunk64_vkGetAccelerationStructureBuildSizesKHR(void *args)
35815 {
35816     struct vkGetAccelerationStructureBuildSizesKHR_params *params = args;
35817
35818     TRACE("%p, %#x, %p, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);
35819
35820     wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureBuildSizesKHR(wine_device_from_handle(params->device)->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);
35821     return STATUS_SUCCESS;
35822 }
35823
35824 #else /* USE_STRUCT_CONVERSION */
35825
35826 static NTSTATUS thunk32_vkGetAccelerationStructureBuildSizesKHR(void *args)
35827 {
35828     struct
35829     {
35830         VkDevice device;
35831         VkAccelerationStructureBuildTypeKHR buildType;
35832         const VkAccelerationStructureBuildGeometryInfoKHR32 *pBuildInfo;
35833         const uint32_t *pMaxPrimitiveCounts;
35834         VkAccelerationStructureBuildSizesInfoKHR32 *pSizeInfo;
35835     } *params = args;
35836     VkAccelerationStructureBuildGeometryInfoKHR pBuildInfo_host;
35837     VkAccelerationStructureBuildSizesInfoKHR pSizeInfo_host;
35838     struct conversion_context ctx;
35839
35840     TRACE("%p, %#x, %p, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);
35841
35842     init_conversion_context(&ctx);
35843     convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(&ctx, params->pBuildInfo, &pBuildInfo_host);
35844     convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_host(params->pSizeInfo, &pSizeInfo_host);
35845     wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureBuildSizesKHR(wine_device_from_handle(params->device)->device, params->buildType, &pBuildInfo_host, params->pMaxPrimitiveCounts, &pSizeInfo_host);
35846     convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win32(&pSizeInfo_host, params->pSizeInfo);
35847     free_conversion_context(&ctx);
35848     return STATUS_SUCCESS;
35849 }
35850
35851 #endif /* USE_STRUCT_CONVERSION */
35852
35853 #if !defined(USE_STRUCT_CONVERSION)
35854
35855 static NTSTATUS thunk64_vkGetAccelerationStructureDeviceAddressKHR(void *args)
35856 {
35857     struct vkGetAccelerationStructureDeviceAddressKHR_params *params = args;
35858
35859     TRACE("%p, %p\n", params->device, params->pInfo);
35860
35861     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureDeviceAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
35862     return STATUS_SUCCESS;
35863 }
35864
35865 #else /* USE_STRUCT_CONVERSION */
35866
35867 static NTSTATUS thunk32_vkGetAccelerationStructureDeviceAddressKHR(void *args)
35868 {
35869     struct
35870     {
35871         VkDevice device;
35872         const VkAccelerationStructureDeviceAddressInfoKHR32 *pInfo;
35873         VkDeviceAddress result;
35874     } *params = args;
35875     VkAccelerationStructureDeviceAddressInfoKHR pInfo_host;
35876
35877     TRACE("%p, %p\n", params->device, params->pInfo);
35878
35879     convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
35880     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureDeviceAddressKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
35881     return STATUS_SUCCESS;
35882 }
35883
35884 #endif /* USE_STRUCT_CONVERSION */
35885
35886 #if !defined(USE_STRUCT_CONVERSION)
35887
35888 static NTSTATUS thunk64_vkGetAccelerationStructureHandleNV(void *args)
35889 {
35890     struct vkGetAccelerationStructureHandleNV_params *params = args;
35891
35892     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), wine_dbgstr_longlong(params->dataSize), params->pData);
35893
35894     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureHandleNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, params->dataSize, params->pData);
35895     return STATUS_SUCCESS;
35896 }
35897
35898 #else /* USE_STRUCT_CONVERSION */
35899
35900 static NTSTATUS thunk32_vkGetAccelerationStructureHandleNV(void *args)
35901 {
35902     struct
35903     {
35904         VkDevice device;
35905         VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
35906         size_t dataSize;
35907         void *pData;
35908         VkResult result;
35909     } *params = args;
35910
35911     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), wine_dbgstr_longlong(params->dataSize), params->pData);
35912
35913     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureHandleNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, params->dataSize, params->pData);
35914     return STATUS_SUCCESS;
35915 }
35916
35917 #endif /* USE_STRUCT_CONVERSION */
35918
35919 #if !defined(USE_STRUCT_CONVERSION)
35920
35921 static NTSTATUS thunk64_vkGetAccelerationStructureMemoryRequirementsNV(void *args)
35922 {
35923     struct vkGetAccelerationStructureMemoryRequirementsNV_params *params = args;
35924
35925     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
35926
35927     wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
35928     return STATUS_SUCCESS;
35929 }
35930
35931 #else /* USE_STRUCT_CONVERSION */
35932
35933 static NTSTATUS thunk32_vkGetAccelerationStructureMemoryRequirementsNV(void *args)
35934 {
35935     struct
35936     {
35937         VkDevice device;
35938         const VkAccelerationStructureMemoryRequirementsInfoNV32 *pInfo;
35939         VkMemoryRequirements2KHR32 *pMemoryRequirements;
35940     } *params = args;
35941     VkAccelerationStructureMemoryRequirementsInfoNV pInfo_host;
35942     VkMemoryRequirements2KHR pMemoryRequirements_host;
35943
35944     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
35945
35946     convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32_to_host(params->pInfo, &pInfo_host);
35947     convert_VkMemoryRequirements2KHR_win32_to_host(params->pMemoryRequirements, &pMemoryRequirements_host);
35948     wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
35949     convert_VkMemoryRequirements2KHR_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
35950     return STATUS_SUCCESS;
35951 }
35952
35953 #endif /* USE_STRUCT_CONVERSION */
35954
35955 #if !defined(USE_STRUCT_CONVERSION)
35956
35957 static NTSTATUS thunk64_vkGetBufferDeviceAddress(void *args)
35958 {
35959     struct vkGetBufferDeviceAddress_params *params = args;
35960
35961     TRACE("%p, %p\n", params->device, params->pInfo);
35962
35963     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddress(wine_device_from_handle(params->device)->device, params->pInfo);
35964     return STATUS_SUCCESS;
35965 }
35966
35967 #else /* USE_STRUCT_CONVERSION */
35968
35969 static NTSTATUS thunk32_vkGetBufferDeviceAddress(void *args)
35970 {
35971     struct
35972     {
35973         VkDevice device;
35974         const VkBufferDeviceAddressInfo32 *pInfo;
35975         VkDeviceAddress result;
35976     } *params = args;
35977     VkBufferDeviceAddressInfo pInfo_host;
35978
35979     TRACE("%p, %p\n", params->device, params->pInfo);
35980
35981     convert_VkBufferDeviceAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
35982     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddress(wine_device_from_handle(params->device)->device, &pInfo_host);
35983     return STATUS_SUCCESS;
35984 }
35985
35986 #endif /* USE_STRUCT_CONVERSION */
35987
35988 #if !defined(USE_STRUCT_CONVERSION)
35989
35990 static NTSTATUS thunk64_vkGetBufferDeviceAddressEXT(void *args)
35991 {
35992     struct vkGetBufferDeviceAddressEXT_params *params = args;
35993
35994     TRACE("%p, %p\n", params->device, params->pInfo);
35995
35996     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddressEXT(wine_device_from_handle(params->device)->device, params->pInfo);
35997     return STATUS_SUCCESS;
35998 }
35999
36000 #else /* USE_STRUCT_CONVERSION */
36001
36002 static NTSTATUS thunk32_vkGetBufferDeviceAddressEXT(void *args)
36003 {
36004     struct
36005     {
36006         VkDevice device;
36007         const VkBufferDeviceAddressInfo32 *pInfo;
36008         VkDeviceAddress result;
36009     } *params = args;
36010     VkBufferDeviceAddressInfo pInfo_host;
36011
36012     TRACE("%p, %p\n", params->device, params->pInfo);
36013
36014     convert_VkBufferDeviceAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
36015     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddressEXT(wine_device_from_handle(params->device)->device, &pInfo_host);
36016     return STATUS_SUCCESS;
36017 }
36018
36019 #endif /* USE_STRUCT_CONVERSION */
36020
36021 #if !defined(USE_STRUCT_CONVERSION)
36022
36023 static NTSTATUS thunk64_vkGetBufferDeviceAddressKHR(void *args)
36024 {
36025     struct vkGetBufferDeviceAddressKHR_params *params = args;
36026
36027     TRACE("%p, %p\n", params->device, params->pInfo);
36028
36029     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
36030     return STATUS_SUCCESS;
36031 }
36032
36033 #else /* USE_STRUCT_CONVERSION */
36034
36035 static NTSTATUS thunk32_vkGetBufferDeviceAddressKHR(void *args)
36036 {
36037     struct
36038     {
36039         VkDevice device;
36040         const VkBufferDeviceAddressInfo32 *pInfo;
36041         VkDeviceAddress result;
36042     } *params = args;
36043     VkBufferDeviceAddressInfo pInfo_host;
36044
36045     TRACE("%p, %p\n", params->device, params->pInfo);
36046
36047     convert_VkBufferDeviceAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
36048     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddressKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
36049     return STATUS_SUCCESS;
36050 }
36051
36052 #endif /* USE_STRUCT_CONVERSION */
36053
36054 #if !defined(USE_STRUCT_CONVERSION)
36055
36056 static NTSTATUS thunk64_vkGetBufferMemoryRequirements(void *args)
36057 {
36058     struct vkGetBufferMemoryRequirements_params *params = args;
36059
36060     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->buffer), params->pMemoryRequirements);
36061
36062     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements(wine_device_from_handle(params->device)->device, params->buffer, params->pMemoryRequirements);
36063     return STATUS_SUCCESS;
36064 }
36065
36066 #else /* USE_STRUCT_CONVERSION */
36067
36068 static NTSTATUS thunk32_vkGetBufferMemoryRequirements(void *args)
36069 {
36070     struct
36071     {
36072         VkDevice device;
36073         VkBuffer DECLSPEC_ALIGN(8) buffer;
36074         VkMemoryRequirements32 *pMemoryRequirements;
36075     } *params = args;
36076     VkMemoryRequirements pMemoryRequirements_host;
36077
36078     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->buffer), params->pMemoryRequirements);
36079
36080     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements(wine_device_from_handle(params->device)->device, params->buffer, &pMemoryRequirements_host);
36081     convert_VkMemoryRequirements_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
36082     return STATUS_SUCCESS;
36083 }
36084
36085 #endif /* USE_STRUCT_CONVERSION */
36086
36087 #if !defined(USE_STRUCT_CONVERSION)
36088
36089 static NTSTATUS thunk64_vkGetBufferMemoryRequirements2(void *args)
36090 {
36091     struct vkGetBufferMemoryRequirements2_params *params = args;
36092
36093     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36094
36095     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements2(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36096     return STATUS_SUCCESS;
36097 }
36098
36099 #else /* USE_STRUCT_CONVERSION */
36100
36101 static NTSTATUS thunk32_vkGetBufferMemoryRequirements2(void *args)
36102 {
36103     struct
36104     {
36105         VkDevice device;
36106         const VkBufferMemoryRequirementsInfo232 *pInfo;
36107         VkMemoryRequirements232 *pMemoryRequirements;
36108     } *params = args;
36109     VkBufferMemoryRequirementsInfo2 pInfo_host;
36110     VkMemoryRequirements2 pMemoryRequirements_host;
36111     struct conversion_context ctx;
36112
36113     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36114
36115     init_conversion_context(&ctx);
36116     convert_VkBufferMemoryRequirementsInfo2_win32_to_host(params->pInfo, &pInfo_host);
36117     convert_VkMemoryRequirements2_win32_to_host(&ctx, params->pMemoryRequirements, &pMemoryRequirements_host);
36118     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements2(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
36119     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
36120     free_conversion_context(&ctx);
36121     return STATUS_SUCCESS;
36122 }
36123
36124 #endif /* USE_STRUCT_CONVERSION */
36125
36126 #if !defined(USE_STRUCT_CONVERSION)
36127
36128 static NTSTATUS thunk64_vkGetBufferMemoryRequirements2KHR(void *args)
36129 {
36130     struct vkGetBufferMemoryRequirements2KHR_params *params = args;
36131
36132     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36133
36134     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36135     return STATUS_SUCCESS;
36136 }
36137
36138 #else /* USE_STRUCT_CONVERSION */
36139
36140 static NTSTATUS thunk32_vkGetBufferMemoryRequirements2KHR(void *args)
36141 {
36142     struct
36143     {
36144         VkDevice device;
36145         const VkBufferMemoryRequirementsInfo232 *pInfo;
36146         VkMemoryRequirements232 *pMemoryRequirements;
36147     } *params = args;
36148     VkBufferMemoryRequirementsInfo2 pInfo_host;
36149     VkMemoryRequirements2 pMemoryRequirements_host;
36150     struct conversion_context ctx;
36151
36152     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36153
36154     init_conversion_context(&ctx);
36155     convert_VkBufferMemoryRequirementsInfo2_win32_to_host(params->pInfo, &pInfo_host);
36156     convert_VkMemoryRequirements2_win32_to_host(&ctx, params->pMemoryRequirements, &pMemoryRequirements_host);
36157     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
36158     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
36159     free_conversion_context(&ctx);
36160     return STATUS_SUCCESS;
36161 }
36162
36163 #endif /* USE_STRUCT_CONVERSION */
36164
36165 #if !defined(USE_STRUCT_CONVERSION)
36166
36167 static NTSTATUS thunk64_vkGetBufferOpaqueCaptureAddress(void *args)
36168 {
36169     struct vkGetBufferOpaqueCaptureAddress_params *params = args;
36170
36171     TRACE("%p, %p\n", params->device, params->pInfo);
36172
36173     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureAddress(wine_device_from_handle(params->device)->device, params->pInfo);
36174     return STATUS_SUCCESS;
36175 }
36176
36177 #else /* USE_STRUCT_CONVERSION */
36178
36179 static NTSTATUS thunk32_vkGetBufferOpaqueCaptureAddress(void *args)
36180 {
36181     struct
36182     {
36183         VkDevice device;
36184         const VkBufferDeviceAddressInfo32 *pInfo;
36185         uint64_t result;
36186     } *params = args;
36187     VkBufferDeviceAddressInfo pInfo_host;
36188
36189     TRACE("%p, %p\n", params->device, params->pInfo);
36190
36191     convert_VkBufferDeviceAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
36192     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureAddress(wine_device_from_handle(params->device)->device, &pInfo_host);
36193     return STATUS_SUCCESS;
36194 }
36195
36196 #endif /* USE_STRUCT_CONVERSION */
36197
36198 #if !defined(USE_STRUCT_CONVERSION)
36199
36200 static NTSTATUS thunk64_vkGetBufferOpaqueCaptureAddressKHR(void *args)
36201 {
36202     struct vkGetBufferOpaqueCaptureAddressKHR_params *params = args;
36203
36204     TRACE("%p, %p\n", params->device, params->pInfo);
36205
36206     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
36207     return STATUS_SUCCESS;
36208 }
36209
36210 #else /* USE_STRUCT_CONVERSION */
36211
36212 static NTSTATUS thunk32_vkGetBufferOpaqueCaptureAddressKHR(void *args)
36213 {
36214     struct
36215     {
36216         VkDevice device;
36217         const VkBufferDeviceAddressInfo32 *pInfo;
36218         uint64_t result;
36219     } *params = args;
36220     VkBufferDeviceAddressInfo pInfo_host;
36221
36222     TRACE("%p, %p\n", params->device, params->pInfo);
36223
36224     convert_VkBufferDeviceAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
36225     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureAddressKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
36226     return STATUS_SUCCESS;
36227 }
36228
36229 #endif /* USE_STRUCT_CONVERSION */
36230
36231 #if !defined(USE_STRUCT_CONVERSION)
36232
36233 static NTSTATUS thunk64_vkGetCalibratedTimestampsEXT(void *args)
36234 {
36235     struct vkGetCalibratedTimestampsEXT_params *params = args;
36236
36237     TRACE("%p, %u, %p, %p, %p\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
36238
36239     params->result = wine_vkGetCalibratedTimestampsEXT(params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
36240     return STATUS_SUCCESS;
36241 }
36242
36243 #else /* USE_STRUCT_CONVERSION */
36244
36245 static NTSTATUS thunk32_vkGetCalibratedTimestampsEXT(void *args)
36246 {
36247     struct
36248     {
36249         VkDevice device;
36250         uint32_t timestampCount;
36251         const VkCalibratedTimestampInfoEXT32 *pTimestampInfos;
36252         uint64_t *pTimestamps;
36253         uint64_t *pMaxDeviation;
36254         VkResult result;
36255     } *params = args;
36256     const VkCalibratedTimestampInfoEXT *pTimestampInfos_host;
36257     struct conversion_context ctx;
36258
36259     TRACE("%p, %u, %p, %p, %p\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
36260
36261     init_conversion_context(&ctx);
36262     pTimestampInfos_host = convert_VkCalibratedTimestampInfoEXT_array_win32_to_host(&ctx, params->pTimestampInfos, params->timestampCount);
36263     params->result = wine_vkGetCalibratedTimestampsEXT(params->device, params->timestampCount, pTimestampInfos_host, params->pTimestamps, params->pMaxDeviation);
36264     free_conversion_context(&ctx);
36265     return STATUS_SUCCESS;
36266 }
36267
36268 #endif /* USE_STRUCT_CONVERSION */
36269
36270 #if !defined(USE_STRUCT_CONVERSION)
36271
36272 static NTSTATUS thunk64_vkGetDeferredOperationMaxConcurrencyKHR(void *args)
36273 {
36274     struct vkGetDeferredOperationMaxConcurrencyKHR_params *params = args;
36275
36276     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
36277
36278     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationMaxConcurrencyKHR(wine_device_from_handle(params->device)->device, params->operation);
36279     return STATUS_SUCCESS;
36280 }
36281
36282 #else /* USE_STRUCT_CONVERSION */
36283
36284 static NTSTATUS thunk32_vkGetDeferredOperationMaxConcurrencyKHR(void *args)
36285 {
36286     struct
36287     {
36288         VkDevice device;
36289         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
36290         uint32_t result;
36291     } *params = args;
36292
36293     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
36294
36295     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationMaxConcurrencyKHR(wine_device_from_handle(params->device)->device, params->operation);
36296     return STATUS_SUCCESS;
36297 }
36298
36299 #endif /* USE_STRUCT_CONVERSION */
36300
36301 #if !defined(USE_STRUCT_CONVERSION)
36302
36303 static NTSTATUS thunk64_vkGetDeferredOperationResultKHR(void *args)
36304 {
36305     struct vkGetDeferredOperationResultKHR_params *params = args;
36306
36307     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
36308
36309     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationResultKHR(wine_device_from_handle(params->device)->device, params->operation);
36310     return STATUS_SUCCESS;
36311 }
36312
36313 #else /* USE_STRUCT_CONVERSION */
36314
36315 static NTSTATUS thunk32_vkGetDeferredOperationResultKHR(void *args)
36316 {
36317     struct
36318     {
36319         VkDevice device;
36320         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
36321         VkResult result;
36322     } *params = args;
36323
36324     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
36325
36326     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationResultKHR(wine_device_from_handle(params->device)->device, params->operation);
36327     return STATUS_SUCCESS;
36328 }
36329
36330 #endif /* USE_STRUCT_CONVERSION */
36331
36332 #if !defined(USE_STRUCT_CONVERSION)
36333
36334 static NTSTATUS thunk64_vkGetDescriptorSetHostMappingVALVE(void *args)
36335 {
36336     struct vkGetDescriptorSetHostMappingVALVE_params *params = args;
36337
36338     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), params->ppData);
36339
36340     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetHostMappingVALVE(wine_device_from_handle(params->device)->device, params->descriptorSet, params->ppData);
36341     return STATUS_SUCCESS;
36342 }
36343
36344 #else /* USE_STRUCT_CONVERSION */
36345
36346 static NTSTATUS thunk32_vkGetDescriptorSetHostMappingVALVE(void *args)
36347 {
36348     struct
36349     {
36350         VkDevice device;
36351         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
36352         void **ppData;
36353     } *params = args;
36354
36355     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), params->ppData);
36356
36357     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetHostMappingVALVE(wine_device_from_handle(params->device)->device, params->descriptorSet, params->ppData);
36358     return STATUS_SUCCESS;
36359 }
36360
36361 #endif /* USE_STRUCT_CONVERSION */
36362
36363 #if !defined(USE_STRUCT_CONVERSION)
36364
36365 static NTSTATUS thunk64_vkGetDescriptorSetLayoutHostMappingInfoVALVE(void *args)
36366 {
36367     struct vkGetDescriptorSetLayoutHostMappingInfoVALVE_params *params = args;
36368
36369     TRACE("%p, %p, %p\n", params->device, params->pBindingReference, params->pHostMapping);
36370
36371     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutHostMappingInfoVALVE(wine_device_from_handle(params->device)->device, params->pBindingReference, params->pHostMapping);
36372     return STATUS_SUCCESS;
36373 }
36374
36375 #else /* USE_STRUCT_CONVERSION */
36376
36377 static NTSTATUS thunk32_vkGetDescriptorSetLayoutHostMappingInfoVALVE(void *args)
36378 {
36379     struct
36380     {
36381         VkDevice device;
36382         const VkDescriptorSetBindingReferenceVALVE32 *pBindingReference;
36383         VkDescriptorSetLayoutHostMappingInfoVALVE32 *pHostMapping;
36384     } *params = args;
36385     VkDescriptorSetBindingReferenceVALVE pBindingReference_host;
36386     VkDescriptorSetLayoutHostMappingInfoVALVE pHostMapping_host;
36387
36388     TRACE("%p, %p, %p\n", params->device, params->pBindingReference, params->pHostMapping);
36389
36390     convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host(params->pBindingReference, &pBindingReference_host);
36391     convert_VkDescriptorSetLayoutHostMappingInfoVALVE_win32_to_host(params->pHostMapping, &pHostMapping_host);
36392     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutHostMappingInfoVALVE(wine_device_from_handle(params->device)->device, &pBindingReference_host, &pHostMapping_host);
36393     convert_VkDescriptorSetLayoutHostMappingInfoVALVE_host_to_win32(&pHostMapping_host, params->pHostMapping);
36394     return STATUS_SUCCESS;
36395 }
36396
36397 #endif /* USE_STRUCT_CONVERSION */
36398
36399 #if !defined(USE_STRUCT_CONVERSION)
36400
36401 static NTSTATUS thunk64_vkGetDescriptorSetLayoutSupport(void *args)
36402 {
36403     struct vkGetDescriptorSetLayoutSupport_params *params = args;
36404
36405     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pSupport);
36406
36407     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSupport(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pSupport);
36408     return STATUS_SUCCESS;
36409 }
36410
36411 #else /* USE_STRUCT_CONVERSION */
36412
36413 static NTSTATUS thunk32_vkGetDescriptorSetLayoutSupport(void *args)
36414 {
36415     struct
36416     {
36417         VkDevice device;
36418         const VkDescriptorSetLayoutCreateInfo32 *pCreateInfo;
36419         VkDescriptorSetLayoutSupport32 *pSupport;
36420     } *params = args;
36421     VkDescriptorSetLayoutCreateInfo pCreateInfo_host;
36422     VkDescriptorSetLayoutSupport pSupport_host;
36423     struct conversion_context ctx;
36424
36425     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pSupport);
36426
36427     init_conversion_context(&ctx);
36428     convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
36429     convert_VkDescriptorSetLayoutSupport_win32_to_host(&ctx, params->pSupport, &pSupport_host);
36430     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSupport(wine_device_from_handle(params->device)->device, &pCreateInfo_host, &pSupport_host);
36431     convert_VkDescriptorSetLayoutSupport_host_to_win32(&pSupport_host, params->pSupport);
36432     free_conversion_context(&ctx);
36433     return STATUS_SUCCESS;
36434 }
36435
36436 #endif /* USE_STRUCT_CONVERSION */
36437
36438 #if !defined(USE_STRUCT_CONVERSION)
36439
36440 static NTSTATUS thunk64_vkGetDescriptorSetLayoutSupportKHR(void *args)
36441 {
36442     struct vkGetDescriptorSetLayoutSupportKHR_params *params = args;
36443
36444     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pSupport);
36445
36446     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSupportKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pSupport);
36447     return STATUS_SUCCESS;
36448 }
36449
36450 #else /* USE_STRUCT_CONVERSION */
36451
36452 static NTSTATUS thunk32_vkGetDescriptorSetLayoutSupportKHR(void *args)
36453 {
36454     struct
36455     {
36456         VkDevice device;
36457         const VkDescriptorSetLayoutCreateInfo32 *pCreateInfo;
36458         VkDescriptorSetLayoutSupport32 *pSupport;
36459     } *params = args;
36460     VkDescriptorSetLayoutCreateInfo pCreateInfo_host;
36461     VkDescriptorSetLayoutSupport pSupport_host;
36462     struct conversion_context ctx;
36463
36464     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pSupport);
36465
36466     init_conversion_context(&ctx);
36467     convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
36468     convert_VkDescriptorSetLayoutSupport_win32_to_host(&ctx, params->pSupport, &pSupport_host);
36469     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSupportKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, &pSupport_host);
36470     convert_VkDescriptorSetLayoutSupport_host_to_win32(&pSupport_host, params->pSupport);
36471     free_conversion_context(&ctx);
36472     return STATUS_SUCCESS;
36473 }
36474
36475 #endif /* USE_STRUCT_CONVERSION */
36476
36477 #if !defined(USE_STRUCT_CONVERSION)
36478
36479 static NTSTATUS thunk64_vkGetDeviceAccelerationStructureCompatibilityKHR(void *args)
36480 {
36481     struct vkGetDeviceAccelerationStructureCompatibilityKHR_params *params = args;
36482
36483     TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
36484
36485     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceAccelerationStructureCompatibilityKHR(wine_device_from_handle(params->device)->device, params->pVersionInfo, params->pCompatibility);
36486     return STATUS_SUCCESS;
36487 }
36488
36489 #else /* USE_STRUCT_CONVERSION */
36490
36491 static NTSTATUS thunk32_vkGetDeviceAccelerationStructureCompatibilityKHR(void *args)
36492 {
36493     struct
36494     {
36495         VkDevice device;
36496         const VkAccelerationStructureVersionInfoKHR32 *pVersionInfo;
36497         VkAccelerationStructureCompatibilityKHR *pCompatibility;
36498     } *params = args;
36499     VkAccelerationStructureVersionInfoKHR pVersionInfo_host;
36500
36501     TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
36502
36503     convert_VkAccelerationStructureVersionInfoKHR_win32_to_host(params->pVersionInfo, &pVersionInfo_host);
36504     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceAccelerationStructureCompatibilityKHR(wine_device_from_handle(params->device)->device, &pVersionInfo_host, params->pCompatibility);
36505     return STATUS_SUCCESS;
36506 }
36507
36508 #endif /* USE_STRUCT_CONVERSION */
36509
36510 #if !defined(USE_STRUCT_CONVERSION)
36511
36512 static NTSTATUS thunk64_vkGetDeviceBufferMemoryRequirements(void *args)
36513 {
36514     struct vkGetDeviceBufferMemoryRequirements_params *params = args;
36515
36516     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36517
36518     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceBufferMemoryRequirements(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36519     return STATUS_SUCCESS;
36520 }
36521
36522 #else /* USE_STRUCT_CONVERSION */
36523
36524 static NTSTATUS thunk32_vkGetDeviceBufferMemoryRequirements(void *args)
36525 {
36526     struct
36527     {
36528         VkDevice device;
36529         const VkDeviceBufferMemoryRequirements32 *pInfo;
36530         VkMemoryRequirements232 *pMemoryRequirements;
36531     } *params = args;
36532     VkDeviceBufferMemoryRequirements pInfo_host;
36533     VkMemoryRequirements2 pMemoryRequirements_host;
36534     struct conversion_context ctx;
36535
36536     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36537
36538     init_conversion_context(&ctx);
36539     convert_VkDeviceBufferMemoryRequirements_win32_to_host(&ctx, params->pInfo, &pInfo_host);
36540     convert_VkMemoryRequirements2_win32_to_host(&ctx, params->pMemoryRequirements, &pMemoryRequirements_host);
36541     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceBufferMemoryRequirements(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
36542     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
36543     free_conversion_context(&ctx);
36544     return STATUS_SUCCESS;
36545 }
36546
36547 #endif /* USE_STRUCT_CONVERSION */
36548
36549 #if !defined(USE_STRUCT_CONVERSION)
36550
36551 static NTSTATUS thunk64_vkGetDeviceBufferMemoryRequirementsKHR(void *args)
36552 {
36553     struct vkGetDeviceBufferMemoryRequirementsKHR_params *params = args;
36554
36555     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36556
36557     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceBufferMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36558     return STATUS_SUCCESS;
36559 }
36560
36561 #else /* USE_STRUCT_CONVERSION */
36562
36563 static NTSTATUS thunk32_vkGetDeviceBufferMemoryRequirementsKHR(void *args)
36564 {
36565     struct
36566     {
36567         VkDevice device;
36568         const VkDeviceBufferMemoryRequirements32 *pInfo;
36569         VkMemoryRequirements232 *pMemoryRequirements;
36570     } *params = args;
36571     VkDeviceBufferMemoryRequirements pInfo_host;
36572     VkMemoryRequirements2 pMemoryRequirements_host;
36573     struct conversion_context ctx;
36574
36575     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36576
36577     init_conversion_context(&ctx);
36578     convert_VkDeviceBufferMemoryRequirements_win32_to_host(&ctx, params->pInfo, &pInfo_host);
36579     convert_VkMemoryRequirements2_win32_to_host(&ctx, params->pMemoryRequirements, &pMemoryRequirements_host);
36580     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceBufferMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
36581     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
36582     free_conversion_context(&ctx);
36583     return STATUS_SUCCESS;
36584 }
36585
36586 #endif /* USE_STRUCT_CONVERSION */
36587
36588 #if !defined(USE_STRUCT_CONVERSION)
36589
36590 static NTSTATUS thunk64_vkGetDeviceFaultInfoEXT(void *args)
36591 {
36592     struct vkGetDeviceFaultInfoEXT_params *params = args;
36593
36594     TRACE("%p, %p, %p\n", params->device, params->pFaultCounts, params->pFaultInfo);
36595
36596     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceFaultInfoEXT(wine_device_from_handle(params->device)->device, params->pFaultCounts, params->pFaultInfo);
36597     return STATUS_SUCCESS;
36598 }
36599
36600 #else /* USE_STRUCT_CONVERSION */
36601
36602 static NTSTATUS thunk32_vkGetDeviceFaultInfoEXT(void *args)
36603 {
36604     struct
36605     {
36606         VkDevice device;
36607         VkDeviceFaultCountsEXT32 *pFaultCounts;
36608         VkDeviceFaultInfoEXT32 *pFaultInfo;
36609         VkResult result;
36610     } *params = args;
36611     VkDeviceFaultCountsEXT pFaultCounts_host;
36612     VkDeviceFaultInfoEXT *pFaultInfo_host = NULL;
36613     struct conversion_context ctx;
36614
36615     TRACE("%p, %p, %p\n", params->device, params->pFaultCounts, params->pFaultInfo);
36616
36617     init_conversion_context(&ctx);
36618     convert_VkDeviceFaultCountsEXT_win32_to_host(params->pFaultCounts, &pFaultCounts_host);
36619     if (params->pFaultInfo)
36620     {
36621         pFaultInfo_host = conversion_context_alloc(&ctx, sizeof(*pFaultInfo_host));
36622         convert_VkDeviceFaultInfoEXT_win32_to_host(&ctx, params->pFaultInfo, pFaultInfo_host);
36623     }
36624     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceFaultInfoEXT(wine_device_from_handle(params->device)->device, &pFaultCounts_host, pFaultInfo_host);
36625     convert_VkDeviceFaultCountsEXT_host_to_win32(&pFaultCounts_host, params->pFaultCounts);
36626     convert_VkDeviceFaultInfoEXT_host_to_win32(pFaultInfo_host, params->pFaultInfo);
36627     free_conversion_context(&ctx);
36628     return STATUS_SUCCESS;
36629 }
36630
36631 #endif /* USE_STRUCT_CONVERSION */
36632
36633 #if !defined(USE_STRUCT_CONVERSION)
36634
36635 static NTSTATUS thunk64_vkGetDeviceGroupPeerMemoryFeatures(void *args)
36636 {
36637     struct vkGetDeviceGroupPeerMemoryFeatures_params *params = args;
36638
36639     TRACE("%p, %u, %u, %u, %p\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36640
36641     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPeerMemoryFeatures(wine_device_from_handle(params->device)->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36642     return STATUS_SUCCESS;
36643 }
36644
36645 #else /* USE_STRUCT_CONVERSION */
36646
36647 static NTSTATUS thunk32_vkGetDeviceGroupPeerMemoryFeatures(void *args)
36648 {
36649     struct
36650     {
36651         VkDevice device;
36652         uint32_t heapIndex;
36653         uint32_t localDeviceIndex;
36654         uint32_t remoteDeviceIndex;
36655         VkPeerMemoryFeatureFlags *pPeerMemoryFeatures;
36656     } *params = args;
36657
36658     TRACE("%p, %u, %u, %u, %p\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36659
36660     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPeerMemoryFeatures(wine_device_from_handle(params->device)->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36661     return STATUS_SUCCESS;
36662 }
36663
36664 #endif /* USE_STRUCT_CONVERSION */
36665
36666 #if !defined(USE_STRUCT_CONVERSION)
36667
36668 static NTSTATUS thunk64_vkGetDeviceGroupPeerMemoryFeaturesKHR(void *args)
36669 {
36670     struct vkGetDeviceGroupPeerMemoryFeaturesKHR_params *params = args;
36671
36672     TRACE("%p, %u, %u, %u, %p\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36673
36674     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPeerMemoryFeaturesKHR(wine_device_from_handle(params->device)->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36675     return STATUS_SUCCESS;
36676 }
36677
36678 #else /* USE_STRUCT_CONVERSION */
36679
36680 static NTSTATUS thunk32_vkGetDeviceGroupPeerMemoryFeaturesKHR(void *args)
36681 {
36682     struct
36683     {
36684         VkDevice device;
36685         uint32_t heapIndex;
36686         uint32_t localDeviceIndex;
36687         uint32_t remoteDeviceIndex;
36688         VkPeerMemoryFeatureFlags *pPeerMemoryFeatures;
36689     } *params = args;
36690
36691     TRACE("%p, %u, %u, %u, %p\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36692
36693     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPeerMemoryFeaturesKHR(wine_device_from_handle(params->device)->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36694     return STATUS_SUCCESS;
36695 }
36696
36697 #endif /* USE_STRUCT_CONVERSION */
36698
36699 #if !defined(USE_STRUCT_CONVERSION)
36700
36701 static NTSTATUS thunk64_vkGetDeviceGroupPresentCapabilitiesKHR(void *args)
36702 {
36703     struct vkGetDeviceGroupPresentCapabilitiesKHR_params *params = args;
36704
36705     TRACE("%p, %p\n", params->device, params->pDeviceGroupPresentCapabilities);
36706
36707     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(wine_device_from_handle(params->device)->device, params->pDeviceGroupPresentCapabilities);
36708     return STATUS_SUCCESS;
36709 }
36710
36711 #else /* USE_STRUCT_CONVERSION */
36712
36713 static NTSTATUS thunk32_vkGetDeviceGroupPresentCapabilitiesKHR(void *args)
36714 {
36715     struct
36716     {
36717         VkDevice device;
36718         VkDeviceGroupPresentCapabilitiesKHR32 *pDeviceGroupPresentCapabilities;
36719         VkResult result;
36720     } *params = args;
36721     VkDeviceGroupPresentCapabilitiesKHR pDeviceGroupPresentCapabilities_host;
36722
36723     TRACE("%p, %p\n", params->device, params->pDeviceGroupPresentCapabilities);
36724
36725     convert_VkDeviceGroupPresentCapabilitiesKHR_win32_to_host(params->pDeviceGroupPresentCapabilities, &pDeviceGroupPresentCapabilities_host);
36726     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(wine_device_from_handle(params->device)->device, &pDeviceGroupPresentCapabilities_host);
36727     convert_VkDeviceGroupPresentCapabilitiesKHR_host_to_win32(&pDeviceGroupPresentCapabilities_host, params->pDeviceGroupPresentCapabilities);
36728     return STATUS_SUCCESS;
36729 }
36730
36731 #endif /* USE_STRUCT_CONVERSION */
36732
36733 #if !defined(USE_STRUCT_CONVERSION)
36734
36735 static NTSTATUS thunk64_vkGetDeviceGroupSurfacePresentModesKHR(void *args)
36736 {
36737     struct vkGetDeviceGroupSurfacePresentModesKHR_params *params = args;
36738
36739     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->surface), params->pModes);
36740
36741     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupSurfacePresentModesKHR(wine_device_from_handle(params->device)->device, wine_surface_from_handle(params->surface)->driver_surface, params->pModes);
36742     return STATUS_SUCCESS;
36743 }
36744
36745 #else /* USE_STRUCT_CONVERSION */
36746
36747 static NTSTATUS thunk32_vkGetDeviceGroupSurfacePresentModesKHR(void *args)
36748 {
36749     struct
36750     {
36751         VkDevice device;
36752         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
36753         VkDeviceGroupPresentModeFlagsKHR *pModes;
36754         VkResult result;
36755     } *params = args;
36756
36757     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->surface), params->pModes);
36758
36759     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupSurfacePresentModesKHR(wine_device_from_handle(params->device)->device, wine_surface_from_handle(params->surface)->driver_surface, params->pModes);
36760     return STATUS_SUCCESS;
36761 }
36762
36763 #endif /* USE_STRUCT_CONVERSION */
36764
36765 #if !defined(USE_STRUCT_CONVERSION)
36766
36767 static NTSTATUS thunk64_vkGetDeviceImageMemoryRequirements(void *args)
36768 {
36769     struct vkGetDeviceImageMemoryRequirements_params *params = args;
36770
36771     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36772
36773     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageMemoryRequirements(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36774     return STATUS_SUCCESS;
36775 }
36776
36777 #else /* USE_STRUCT_CONVERSION */
36778
36779 static NTSTATUS thunk32_vkGetDeviceImageMemoryRequirements(void *args)
36780 {
36781     struct
36782     {
36783         VkDevice device;
36784         const VkDeviceImageMemoryRequirements32 *pInfo;
36785         VkMemoryRequirements232 *pMemoryRequirements;
36786     } *params = args;
36787     VkDeviceImageMemoryRequirements pInfo_host;
36788     VkMemoryRequirements2 pMemoryRequirements_host;
36789     struct conversion_context ctx;
36790
36791     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36792
36793     init_conversion_context(&ctx);
36794     convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, params->pInfo, &pInfo_host);
36795     convert_VkMemoryRequirements2_win32_to_host(&ctx, params->pMemoryRequirements, &pMemoryRequirements_host);
36796     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageMemoryRequirements(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
36797     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
36798     free_conversion_context(&ctx);
36799     return STATUS_SUCCESS;
36800 }
36801
36802 #endif /* USE_STRUCT_CONVERSION */
36803
36804 #if !defined(USE_STRUCT_CONVERSION)
36805
36806 static NTSTATUS thunk64_vkGetDeviceImageMemoryRequirementsKHR(void *args)
36807 {
36808     struct vkGetDeviceImageMemoryRequirementsKHR_params *params = args;
36809
36810     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36811
36812     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36813     return STATUS_SUCCESS;
36814 }
36815
36816 #else /* USE_STRUCT_CONVERSION */
36817
36818 static NTSTATUS thunk32_vkGetDeviceImageMemoryRequirementsKHR(void *args)
36819 {
36820     struct
36821     {
36822         VkDevice device;
36823         const VkDeviceImageMemoryRequirements32 *pInfo;
36824         VkMemoryRequirements232 *pMemoryRequirements;
36825     } *params = args;
36826     VkDeviceImageMemoryRequirements pInfo_host;
36827     VkMemoryRequirements2 pMemoryRequirements_host;
36828     struct conversion_context ctx;
36829
36830     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36831
36832     init_conversion_context(&ctx);
36833     convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, params->pInfo, &pInfo_host);
36834     convert_VkMemoryRequirements2_win32_to_host(&ctx, params->pMemoryRequirements, &pMemoryRequirements_host);
36835     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
36836     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
36837     free_conversion_context(&ctx);
36838     return STATUS_SUCCESS;
36839 }
36840
36841 #endif /* USE_STRUCT_CONVERSION */
36842
36843 #if !defined(USE_STRUCT_CONVERSION)
36844
36845 static NTSTATUS thunk64_vkGetDeviceImageSparseMemoryRequirements(void *args)
36846 {
36847     struct vkGetDeviceImageSparseMemoryRequirements_params *params = args;
36848
36849     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36850
36851     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageSparseMemoryRequirements(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36852     return STATUS_SUCCESS;
36853 }
36854
36855 #else /* USE_STRUCT_CONVERSION */
36856
36857 static NTSTATUS thunk32_vkGetDeviceImageSparseMemoryRequirements(void *args)
36858 {
36859     struct
36860     {
36861         VkDevice device;
36862         const VkDeviceImageMemoryRequirements32 *pInfo;
36863         uint32_t *pSparseMemoryRequirementCount;
36864         VkSparseImageMemoryRequirements232 *pSparseMemoryRequirements;
36865     } *params = args;
36866     VkDeviceImageMemoryRequirements pInfo_host;
36867     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
36868     struct conversion_context ctx;
36869
36870     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36871
36872     init_conversion_context(&ctx);
36873     convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, params->pInfo, &pInfo_host);
36874     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
36875     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageSparseMemoryRequirements(wine_device_from_handle(params->device)->device, &pInfo_host, params->pSparseMemoryRequirementCount, pSparseMemoryRequirements_host);
36876     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
36877     free_conversion_context(&ctx);
36878     return STATUS_SUCCESS;
36879 }
36880
36881 #endif /* USE_STRUCT_CONVERSION */
36882
36883 #if !defined(USE_STRUCT_CONVERSION)
36884
36885 static NTSTATUS thunk64_vkGetDeviceImageSparseMemoryRequirementsKHR(void *args)
36886 {
36887     struct vkGetDeviceImageSparseMemoryRequirementsKHR_params *params = args;
36888
36889     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36890
36891     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageSparseMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36892     return STATUS_SUCCESS;
36893 }
36894
36895 #else /* USE_STRUCT_CONVERSION */
36896
36897 static NTSTATUS thunk32_vkGetDeviceImageSparseMemoryRequirementsKHR(void *args)
36898 {
36899     struct
36900     {
36901         VkDevice device;
36902         const VkDeviceImageMemoryRequirements32 *pInfo;
36903         uint32_t *pSparseMemoryRequirementCount;
36904         VkSparseImageMemoryRequirements232 *pSparseMemoryRequirements;
36905     } *params = args;
36906     VkDeviceImageMemoryRequirements pInfo_host;
36907     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
36908     struct conversion_context ctx;
36909
36910     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36911
36912     init_conversion_context(&ctx);
36913     convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, params->pInfo, &pInfo_host);
36914     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
36915     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageSparseMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, &pInfo_host, params->pSparseMemoryRequirementCount, pSparseMemoryRequirements_host);
36916     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
36917     free_conversion_context(&ctx);
36918     return STATUS_SUCCESS;
36919 }
36920
36921 #endif /* USE_STRUCT_CONVERSION */
36922
36923 #if !defined(USE_STRUCT_CONVERSION)
36924
36925 static NTSTATUS thunk64_vkGetDeviceMemoryCommitment(void *args)
36926 {
36927     struct vkGetDeviceMemoryCommitment_params *params = args;
36928
36929     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->memory), params->pCommittedMemoryInBytes);
36930
36931     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryCommitment(wine_device_from_handle(params->device)->device, params->memory, params->pCommittedMemoryInBytes);
36932     return STATUS_SUCCESS;
36933 }
36934
36935 #else /* USE_STRUCT_CONVERSION */
36936
36937 static NTSTATUS thunk32_vkGetDeviceMemoryCommitment(void *args)
36938 {
36939     struct
36940     {
36941         VkDevice device;
36942         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
36943         VkDeviceSize *pCommittedMemoryInBytes;
36944     } *params = args;
36945
36946     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->memory), params->pCommittedMemoryInBytes);
36947
36948     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryCommitment(wine_device_from_handle(params->device)->device, params->memory, params->pCommittedMemoryInBytes);
36949     return STATUS_SUCCESS;
36950 }
36951
36952 #endif /* USE_STRUCT_CONVERSION */
36953
36954 #if !defined(USE_STRUCT_CONVERSION)
36955
36956 static NTSTATUS thunk64_vkGetDeviceMemoryOpaqueCaptureAddress(void *args)
36957 {
36958     struct vkGetDeviceMemoryOpaqueCaptureAddress_params *params = args;
36959
36960     TRACE("%p, %p\n", params->device, params->pInfo);
36961
36962     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddress(wine_device_from_handle(params->device)->device, params->pInfo);
36963     return STATUS_SUCCESS;
36964 }
36965
36966 #else /* USE_STRUCT_CONVERSION */
36967
36968 static NTSTATUS thunk32_vkGetDeviceMemoryOpaqueCaptureAddress(void *args)
36969 {
36970     struct
36971     {
36972         VkDevice device;
36973         const VkDeviceMemoryOpaqueCaptureAddressInfo32 *pInfo;
36974         uint64_t result;
36975     } *params = args;
36976     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;
36977
36978     TRACE("%p, %p\n", params->device, params->pInfo);
36979
36980     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
36981     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddress(wine_device_from_handle(params->device)->device, &pInfo_host);
36982     return STATUS_SUCCESS;
36983 }
36984
36985 #endif /* USE_STRUCT_CONVERSION */
36986
36987 #if !defined(USE_STRUCT_CONVERSION)
36988
36989 static NTSTATUS thunk64_vkGetDeviceMemoryOpaqueCaptureAddressKHR(void *args)
36990 {
36991     struct vkGetDeviceMemoryOpaqueCaptureAddressKHR_params *params = args;
36992
36993     TRACE("%p, %p\n", params->device, params->pInfo);
36994
36995     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
36996     return STATUS_SUCCESS;
36997 }
36998
36999 #else /* USE_STRUCT_CONVERSION */
37000
37001 static NTSTATUS thunk32_vkGetDeviceMemoryOpaqueCaptureAddressKHR(void *args)
37002 {
37003     struct
37004     {
37005         VkDevice device;
37006         const VkDeviceMemoryOpaqueCaptureAddressInfo32 *pInfo;
37007         uint64_t result;
37008     } *params = args;
37009     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;
37010
37011     TRACE("%p, %p\n", params->device, params->pInfo);
37012
37013     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
37014     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
37015     return STATUS_SUCCESS;
37016 }
37017
37018 #endif /* USE_STRUCT_CONVERSION */
37019
37020 #if !defined(USE_STRUCT_CONVERSION)
37021
37022 static NTSTATUS thunk64_vkGetDeviceMicromapCompatibilityEXT(void *args)
37023 {
37024     struct vkGetDeviceMicromapCompatibilityEXT_params *params = args;
37025
37026     TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
37027
37028     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMicromapCompatibilityEXT(wine_device_from_handle(params->device)->device, params->pVersionInfo, params->pCompatibility);
37029     return STATUS_SUCCESS;
37030 }
37031
37032 #else /* USE_STRUCT_CONVERSION */
37033
37034 static NTSTATUS thunk32_vkGetDeviceMicromapCompatibilityEXT(void *args)
37035 {
37036     struct
37037     {
37038         VkDevice device;
37039         const VkMicromapVersionInfoEXT32 *pVersionInfo;
37040         VkAccelerationStructureCompatibilityKHR *pCompatibility;
37041     } *params = args;
37042     VkMicromapVersionInfoEXT pVersionInfo_host;
37043
37044     TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
37045
37046     convert_VkMicromapVersionInfoEXT_win32_to_host(params->pVersionInfo, &pVersionInfo_host);
37047     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMicromapCompatibilityEXT(wine_device_from_handle(params->device)->device, &pVersionInfo_host, params->pCompatibility);
37048     return STATUS_SUCCESS;
37049 }
37050
37051 #endif /* USE_STRUCT_CONVERSION */
37052
37053 #if !defined(USE_STRUCT_CONVERSION)
37054
37055 static NTSTATUS thunk64_vkGetDeviceQueue(void *args)
37056 {
37057     struct vkGetDeviceQueue_params *params = args;
37058
37059     TRACE("%p, %u, %u, %p\n", params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
37060
37061     wine_vkGetDeviceQueue(params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
37062     return STATUS_SUCCESS;
37063 }
37064
37065 #else /* USE_STRUCT_CONVERSION */
37066
37067 static NTSTATUS thunk32_vkGetDeviceQueue(void *args)
37068 {
37069     struct
37070     {
37071         VkDevice device;
37072         uint32_t queueFamilyIndex;
37073         uint32_t queueIndex;
37074         VkQueue *pQueue;
37075     } *params = args;
37076
37077     TRACE("%p, %u, %u, %p\n", params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
37078
37079     wine_vkGetDeviceQueue(params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
37080     return STATUS_SUCCESS;
37081 }
37082
37083 #endif /* USE_STRUCT_CONVERSION */
37084
37085 #if !defined(USE_STRUCT_CONVERSION)
37086
37087 static NTSTATUS thunk64_vkGetDeviceQueue2(void *args)
37088 {
37089     struct vkGetDeviceQueue2_params *params = args;
37090
37091     TRACE("%p, %p, %p\n", params->device, params->pQueueInfo, params->pQueue);
37092
37093     wine_vkGetDeviceQueue2(params->device, params->pQueueInfo, params->pQueue);
37094     return STATUS_SUCCESS;
37095 }
37096
37097 #else /* USE_STRUCT_CONVERSION */
37098
37099 static NTSTATUS thunk32_vkGetDeviceQueue2(void *args)
37100 {
37101     struct
37102     {
37103         VkDevice device;
37104         const VkDeviceQueueInfo232 *pQueueInfo;
37105         VkQueue *pQueue;
37106     } *params = args;
37107     VkDeviceQueueInfo2 pQueueInfo_host;
37108
37109     TRACE("%p, %p, %p\n", params->device, params->pQueueInfo, params->pQueue);
37110
37111     convert_VkDeviceQueueInfo2_win32_to_host(params->pQueueInfo, &pQueueInfo_host);
37112     wine_vkGetDeviceQueue2(params->device, &pQueueInfo_host, params->pQueue);
37113     return STATUS_SUCCESS;
37114 }
37115
37116 #endif /* USE_STRUCT_CONVERSION */
37117
37118 #if !defined(USE_STRUCT_CONVERSION)
37119
37120 static NTSTATUS thunk64_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(void *args)
37121 {
37122     struct vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_params *params = args;
37123
37124     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderpass), params->pMaxWorkgroupSize);
37125
37126     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(wine_device_from_handle(params->device)->device, params->renderpass, params->pMaxWorkgroupSize);
37127     return STATUS_SUCCESS;
37128 }
37129
37130 #else /* USE_STRUCT_CONVERSION */
37131
37132 static NTSTATUS thunk32_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(void *args)
37133 {
37134     struct
37135     {
37136         VkDevice device;
37137         VkRenderPass DECLSPEC_ALIGN(8) renderpass;
37138         VkExtent2D *pMaxWorkgroupSize;
37139         VkResult result;
37140     } *params = args;
37141
37142     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderpass), params->pMaxWorkgroupSize);
37143
37144     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(wine_device_from_handle(params->device)->device, params->renderpass, params->pMaxWorkgroupSize);
37145     return STATUS_SUCCESS;
37146 }
37147
37148 #endif /* USE_STRUCT_CONVERSION */
37149
37150 #if !defined(USE_STRUCT_CONVERSION)
37151
37152 static NTSTATUS thunk64_vkGetDynamicRenderingTilePropertiesQCOM(void *args)
37153 {
37154     struct vkGetDynamicRenderingTilePropertiesQCOM_params *params = args;
37155
37156     TRACE("%p, %p, %p\n", params->device, params->pRenderingInfo, params->pProperties);
37157
37158     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDynamicRenderingTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->pRenderingInfo, params->pProperties);
37159     return STATUS_SUCCESS;
37160 }
37161
37162 #else /* USE_STRUCT_CONVERSION */
37163
37164 static NTSTATUS thunk32_vkGetDynamicRenderingTilePropertiesQCOM(void *args)
37165 {
37166     struct
37167     {
37168         VkDevice device;
37169         const VkRenderingInfo32 *pRenderingInfo;
37170         VkTilePropertiesQCOM32 *pProperties;
37171         VkResult result;
37172     } *params = args;
37173     VkRenderingInfo pRenderingInfo_host;
37174     VkTilePropertiesQCOM pProperties_host;
37175     struct conversion_context ctx;
37176
37177     TRACE("%p, %p, %p\n", params->device, params->pRenderingInfo, params->pProperties);
37178
37179     init_conversion_context(&ctx);
37180     convert_VkRenderingInfo_win32_to_host(&ctx, params->pRenderingInfo, &pRenderingInfo_host);
37181     convert_VkTilePropertiesQCOM_win32_to_host(params->pProperties, &pProperties_host);
37182     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDynamicRenderingTilePropertiesQCOM(wine_device_from_handle(params->device)->device, &pRenderingInfo_host, &pProperties_host);
37183     convert_VkTilePropertiesQCOM_host_to_win32(&pProperties_host, params->pProperties);
37184     free_conversion_context(&ctx);
37185     return STATUS_SUCCESS;
37186 }
37187
37188 #endif /* USE_STRUCT_CONVERSION */
37189
37190 #if !defined(USE_STRUCT_CONVERSION)
37191
37192 static NTSTATUS thunk64_vkGetEventStatus(void *args)
37193 {
37194     struct vkGetEventStatus_params *params = args;
37195
37196     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
37197
37198     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetEventStatus(wine_device_from_handle(params->device)->device, params->event);
37199     return STATUS_SUCCESS;
37200 }
37201
37202 #else /* USE_STRUCT_CONVERSION */
37203
37204 static NTSTATUS thunk32_vkGetEventStatus(void *args)
37205 {
37206     struct
37207     {
37208         VkDevice device;
37209         VkEvent DECLSPEC_ALIGN(8) event;
37210         VkResult result;
37211     } *params = args;
37212
37213     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
37214
37215     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetEventStatus(wine_device_from_handle(params->device)->device, params->event);
37216     return STATUS_SUCCESS;
37217 }
37218
37219 #endif /* USE_STRUCT_CONVERSION */
37220
37221 #if !defined(USE_STRUCT_CONVERSION)
37222
37223 static NTSTATUS thunk64_vkGetFenceStatus(void *args)
37224 {
37225     struct vkGetFenceStatus_params *params = args;
37226
37227     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->fence));
37228
37229     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFenceStatus(wine_device_from_handle(params->device)->device, params->fence);
37230     return STATUS_SUCCESS;
37231 }
37232
37233 #else /* USE_STRUCT_CONVERSION */
37234
37235 static NTSTATUS thunk32_vkGetFenceStatus(void *args)
37236 {
37237     struct
37238     {
37239         VkDevice device;
37240         VkFence DECLSPEC_ALIGN(8) fence;
37241         VkResult result;
37242     } *params = args;
37243
37244     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->fence));
37245
37246     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFenceStatus(wine_device_from_handle(params->device)->device, params->fence);
37247     return STATUS_SUCCESS;
37248 }
37249
37250 #endif /* USE_STRUCT_CONVERSION */
37251
37252 #if !defined(USE_STRUCT_CONVERSION)
37253
37254 static NTSTATUS thunk64_vkGetFramebufferTilePropertiesQCOM(void *args)
37255 {
37256     struct vkGetFramebufferTilePropertiesQCOM_params *params = args;
37257
37258     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pPropertiesCount, params->pProperties);
37259
37260     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFramebufferTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->framebuffer, params->pPropertiesCount, params->pProperties);
37261     return STATUS_SUCCESS;
37262 }
37263
37264 #else /* USE_STRUCT_CONVERSION */
37265
37266 static NTSTATUS thunk32_vkGetFramebufferTilePropertiesQCOM(void *args)
37267 {
37268     struct
37269     {
37270         VkDevice device;
37271         VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
37272         uint32_t *pPropertiesCount;
37273         VkTilePropertiesQCOM32 *pProperties;
37274         VkResult result;
37275     } *params = args;
37276     VkTilePropertiesQCOM *pProperties_host;
37277     struct conversion_context ctx;
37278
37279     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pPropertiesCount, params->pProperties);
37280
37281     init_conversion_context(&ctx);
37282     pProperties_host = convert_VkTilePropertiesQCOM_array_win32_to_host(&ctx, params->pProperties, *params->pPropertiesCount);
37283     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFramebufferTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->framebuffer, params->pPropertiesCount, pProperties_host);
37284     convert_VkTilePropertiesQCOM_array_host_to_win32(pProperties_host, params->pProperties, *params->pPropertiesCount);
37285     free_conversion_context(&ctx);
37286     return STATUS_SUCCESS;
37287 }
37288
37289 #endif /* USE_STRUCT_CONVERSION */
37290
37291 #if !defined(USE_STRUCT_CONVERSION)
37292
37293 static NTSTATUS thunk64_vkGetGeneratedCommandsMemoryRequirementsNV(void *args)
37294 {
37295     struct vkGetGeneratedCommandsMemoryRequirementsNV_params *params = args;
37296
37297     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
37298
37299     wine_device_from_handle(params->device)->funcs.p_vkGetGeneratedCommandsMemoryRequirementsNV(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
37300     return STATUS_SUCCESS;
37301 }
37302
37303 #else /* USE_STRUCT_CONVERSION */
37304
37305 static NTSTATUS thunk32_vkGetGeneratedCommandsMemoryRequirementsNV(void *args)
37306 {
37307     struct
37308     {
37309         VkDevice device;
37310         const VkGeneratedCommandsMemoryRequirementsInfoNV32 *pInfo;
37311         VkMemoryRequirements232 *pMemoryRequirements;
37312     } *params = args;
37313     VkGeneratedCommandsMemoryRequirementsInfoNV pInfo_host;
37314     VkMemoryRequirements2 pMemoryRequirements_host;
37315     struct conversion_context ctx;
37316
37317     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
37318
37319     init_conversion_context(&ctx);
37320     convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host(params->pInfo, &pInfo_host);
37321     convert_VkMemoryRequirements2_win32_to_host(&ctx, params->pMemoryRequirements, &pMemoryRequirements_host);
37322     wine_device_from_handle(params->device)->funcs.p_vkGetGeneratedCommandsMemoryRequirementsNV(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
37323     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
37324     free_conversion_context(&ctx);
37325     return STATUS_SUCCESS;
37326 }
37327
37328 #endif /* USE_STRUCT_CONVERSION */
37329
37330 #if !defined(USE_STRUCT_CONVERSION)
37331
37332 static NTSTATUS thunk64_vkGetImageMemoryRequirements(void *args)
37333 {
37334     struct vkGetImageMemoryRequirements_params *params = args;
37335
37336     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pMemoryRequirements);
37337
37338     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements(wine_device_from_handle(params->device)->device, params->image, params->pMemoryRequirements);
37339     return STATUS_SUCCESS;
37340 }
37341
37342 #else /* USE_STRUCT_CONVERSION */
37343
37344 static NTSTATUS thunk32_vkGetImageMemoryRequirements(void *args)
37345 {
37346     struct
37347     {
37348         VkDevice device;
37349         VkImage DECLSPEC_ALIGN(8) image;
37350         VkMemoryRequirements32 *pMemoryRequirements;
37351     } *params = args;
37352     VkMemoryRequirements pMemoryRequirements_host;
37353
37354     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pMemoryRequirements);
37355
37356     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements(wine_device_from_handle(params->device)->device, params->image, &pMemoryRequirements_host);
37357     convert_VkMemoryRequirements_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
37358     return STATUS_SUCCESS;
37359 }
37360
37361 #endif /* USE_STRUCT_CONVERSION */
37362
37363 #if !defined(USE_STRUCT_CONVERSION)
37364
37365 static NTSTATUS thunk64_vkGetImageMemoryRequirements2(void *args)
37366 {
37367     struct vkGetImageMemoryRequirements2_params *params = args;
37368
37369     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
37370
37371     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements2(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
37372     return STATUS_SUCCESS;
37373 }
37374
37375 #else /* USE_STRUCT_CONVERSION */
37376
37377 static NTSTATUS thunk32_vkGetImageMemoryRequirements2(void *args)
37378 {
37379     struct
37380     {
37381         VkDevice device;
37382         const VkImageMemoryRequirementsInfo232 *pInfo;
37383         VkMemoryRequirements232 *pMemoryRequirements;
37384     } *params = args;
37385     VkImageMemoryRequirementsInfo2 pInfo_host;
37386     VkMemoryRequirements2 pMemoryRequirements_host;
37387     struct conversion_context ctx;
37388
37389     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
37390
37391     init_conversion_context(&ctx);
37392     convert_VkImageMemoryRequirementsInfo2_win32_to_host(&ctx, params->pInfo, &pInfo_host);
37393     convert_VkMemoryRequirements2_win32_to_host(&ctx, params->pMemoryRequirements, &pMemoryRequirements_host);
37394     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements2(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
37395     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
37396     free_conversion_context(&ctx);
37397     return STATUS_SUCCESS;
37398 }
37399
37400 #endif /* USE_STRUCT_CONVERSION */
37401
37402 #if !defined(USE_STRUCT_CONVERSION)
37403
37404 static NTSTATUS thunk64_vkGetImageMemoryRequirements2KHR(void *args)
37405 {
37406     struct vkGetImageMemoryRequirements2KHR_params *params = args;
37407
37408     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
37409
37410     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
37411     return STATUS_SUCCESS;
37412 }
37413
37414 #else /* USE_STRUCT_CONVERSION */
37415
37416 static NTSTATUS thunk32_vkGetImageMemoryRequirements2KHR(void *args)
37417 {
37418     struct
37419     {
37420         VkDevice device;
37421         const VkImageMemoryRequirementsInfo232 *pInfo;
37422         VkMemoryRequirements232 *pMemoryRequirements;
37423     } *params = args;
37424     VkImageMemoryRequirementsInfo2 pInfo_host;
37425     VkMemoryRequirements2 pMemoryRequirements_host;
37426     struct conversion_context ctx;
37427
37428     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
37429
37430     init_conversion_context(&ctx);
37431     convert_VkImageMemoryRequirementsInfo2_win32_to_host(&ctx, params->pInfo, &pInfo_host);
37432     convert_VkMemoryRequirements2_win32_to_host(&ctx, params->pMemoryRequirements, &pMemoryRequirements_host);
37433     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
37434     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
37435     free_conversion_context(&ctx);
37436     return STATUS_SUCCESS;
37437 }
37438
37439 #endif /* USE_STRUCT_CONVERSION */
37440
37441 #if !defined(USE_STRUCT_CONVERSION)
37442
37443 static NTSTATUS thunk64_vkGetImageSparseMemoryRequirements(void *args)
37444 {
37445     struct vkGetImageSparseMemoryRequirements_params *params = args;
37446
37447     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37448
37449     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements(wine_device_from_handle(params->device)->device, params->image, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37450     return STATUS_SUCCESS;
37451 }
37452
37453 #else /* USE_STRUCT_CONVERSION */
37454
37455 static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements(void *args)
37456 {
37457     struct
37458     {
37459         VkDevice device;
37460         VkImage DECLSPEC_ALIGN(8) image;
37461         uint32_t *pSparseMemoryRequirementCount;
37462         VkSparseImageMemoryRequirements32 *pSparseMemoryRequirements;
37463     } *params = args;
37464     VkSparseImageMemoryRequirements *pSparseMemoryRequirements_host;
37465     struct conversion_context ctx;
37466
37467     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37468
37469     init_conversion_context(&ctx);
37470     pSparseMemoryRequirements_host = (params->pSparseMemoryRequirements && *params->pSparseMemoryRequirementCount) ? conversion_context_alloc(&ctx, sizeof(*pSparseMemoryRequirements_host) * *params->pSparseMemoryRequirementCount) : NULL;
37471     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements(wine_device_from_handle(params->device)->device, params->image, params->pSparseMemoryRequirementCount, pSparseMemoryRequirements_host);
37472     convert_VkSparseImageMemoryRequirements_array_host_to_win32(pSparseMemoryRequirements_host, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
37473     free_conversion_context(&ctx);
37474     return STATUS_SUCCESS;
37475 }
37476
37477 #endif /* USE_STRUCT_CONVERSION */
37478
37479 #if !defined(USE_STRUCT_CONVERSION)
37480
37481 static NTSTATUS thunk64_vkGetImageSparseMemoryRequirements2(void *args)
37482 {
37483     struct vkGetImageSparseMemoryRequirements2_params *params = args;
37484
37485     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37486
37487     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements2(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37488     return STATUS_SUCCESS;
37489 }
37490
37491 #else /* USE_STRUCT_CONVERSION */
37492
37493 static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements2(void *args)
37494 {
37495     struct
37496     {
37497         VkDevice device;
37498         const VkImageSparseMemoryRequirementsInfo232 *pInfo;
37499         uint32_t *pSparseMemoryRequirementCount;
37500         VkSparseImageMemoryRequirements232 *pSparseMemoryRequirements;
37501     } *params = args;
37502     VkImageSparseMemoryRequirementsInfo2 pInfo_host;
37503     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
37504     struct conversion_context ctx;
37505
37506     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37507
37508     init_conversion_context(&ctx);
37509     convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host(params->pInfo, &pInfo_host);
37510     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
37511     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements2(wine_device_from_handle(params->device)->device, &pInfo_host, params->pSparseMemoryRequirementCount, pSparseMemoryRequirements_host);
37512     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
37513     free_conversion_context(&ctx);
37514     return STATUS_SUCCESS;
37515 }
37516
37517 #endif /* USE_STRUCT_CONVERSION */
37518
37519 #if !defined(USE_STRUCT_CONVERSION)
37520
37521 static NTSTATUS thunk64_vkGetImageSparseMemoryRequirements2KHR(void *args)
37522 {
37523     struct vkGetImageSparseMemoryRequirements2KHR_params *params = args;
37524
37525     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37526
37527     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37528     return STATUS_SUCCESS;
37529 }
37530
37531 #else /* USE_STRUCT_CONVERSION */
37532
37533 static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements2KHR(void *args)
37534 {
37535     struct
37536     {
37537         VkDevice device;
37538         const VkImageSparseMemoryRequirementsInfo232 *pInfo;
37539         uint32_t *pSparseMemoryRequirementCount;
37540         VkSparseImageMemoryRequirements232 *pSparseMemoryRequirements;
37541     } *params = args;
37542     VkImageSparseMemoryRequirementsInfo2 pInfo_host;
37543     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
37544     struct conversion_context ctx;
37545
37546     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37547
37548     init_conversion_context(&ctx);
37549     convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host(params->pInfo, &pInfo_host);
37550     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
37551     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, &pInfo_host, params->pSparseMemoryRequirementCount, pSparseMemoryRequirements_host);
37552     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
37553     free_conversion_context(&ctx);
37554     return STATUS_SUCCESS;
37555 }
37556
37557 #endif /* USE_STRUCT_CONVERSION */
37558
37559 #if !defined(USE_STRUCT_CONVERSION)
37560
37561 static NTSTATUS thunk64_vkGetImageSubresourceLayout(void *args)
37562 {
37563     struct vkGetImageSubresourceLayout_params *params = args;
37564
37565     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
37566
37567     wine_device_from_handle(params->device)->funcs.p_vkGetImageSubresourceLayout(wine_device_from_handle(params->device)->device, params->image, params->pSubresource, params->pLayout);
37568     return STATUS_SUCCESS;
37569 }
37570
37571 #else /* USE_STRUCT_CONVERSION */
37572
37573 static NTSTATUS thunk32_vkGetImageSubresourceLayout(void *args)
37574 {
37575     struct
37576     {
37577         VkDevice device;
37578         VkImage DECLSPEC_ALIGN(8) image;
37579         const VkImageSubresource *pSubresource;
37580         VkSubresourceLayout32 *pLayout;
37581     } *params = args;
37582     VkSubresourceLayout pLayout_host;
37583
37584     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
37585
37586     wine_device_from_handle(params->device)->funcs.p_vkGetImageSubresourceLayout(wine_device_from_handle(params->device)->device, params->image, params->pSubresource, &pLayout_host);
37587     convert_VkSubresourceLayout_host_to_win32(&pLayout_host, params->pLayout);
37588     return STATUS_SUCCESS;
37589 }
37590
37591 #endif /* USE_STRUCT_CONVERSION */
37592
37593 #if !defined(USE_STRUCT_CONVERSION)
37594
37595 static NTSTATUS thunk64_vkGetImageSubresourceLayout2EXT(void *args)
37596 {
37597     struct vkGetImageSubresourceLayout2EXT_params *params = args;
37598
37599     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
37600
37601     wine_device_from_handle(params->device)->funcs.p_vkGetImageSubresourceLayout2EXT(wine_device_from_handle(params->device)->device, params->image, params->pSubresource, params->pLayout);
37602     return STATUS_SUCCESS;
37603 }
37604
37605 #else /* USE_STRUCT_CONVERSION */
37606
37607 static NTSTATUS thunk32_vkGetImageSubresourceLayout2EXT(void *args)
37608 {
37609     struct
37610     {
37611         VkDevice device;
37612         VkImage DECLSPEC_ALIGN(8) image;
37613         const VkImageSubresource2EXT32 *pSubresource;
37614         VkSubresourceLayout2EXT32 *pLayout;
37615     } *params = args;
37616     VkImageSubresource2EXT pSubresource_host;
37617     VkSubresourceLayout2EXT pLayout_host;
37618     struct conversion_context ctx;
37619
37620     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
37621
37622     init_conversion_context(&ctx);
37623     convert_VkImageSubresource2EXT_win32_to_host(params->pSubresource, &pSubresource_host);
37624     convert_VkSubresourceLayout2EXT_win32_to_host(&ctx, params->pLayout, &pLayout_host);
37625     wine_device_from_handle(params->device)->funcs.p_vkGetImageSubresourceLayout2EXT(wine_device_from_handle(params->device)->device, params->image, &pSubresource_host, &pLayout_host);
37626     convert_VkSubresourceLayout2EXT_host_to_win32(&pLayout_host, params->pLayout);
37627     free_conversion_context(&ctx);
37628     return STATUS_SUCCESS;
37629 }
37630
37631 #endif /* USE_STRUCT_CONVERSION */
37632
37633 #if !defined(USE_STRUCT_CONVERSION)
37634
37635 static NTSTATUS thunk64_vkGetImageViewAddressNVX(void *args)
37636 {
37637     struct vkGetImageViewAddressNVX_params *params = args;
37638
37639     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pProperties);
37640
37641     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewAddressNVX(wine_device_from_handle(params->device)->device, params->imageView, params->pProperties);
37642     return STATUS_SUCCESS;
37643 }
37644
37645 #else /* USE_STRUCT_CONVERSION */
37646
37647 static NTSTATUS thunk32_vkGetImageViewAddressNVX(void *args)
37648 {
37649     struct
37650     {
37651         VkDevice device;
37652         VkImageView DECLSPEC_ALIGN(8) imageView;
37653         VkImageViewAddressPropertiesNVX32 *pProperties;
37654         VkResult result;
37655     } *params = args;
37656     VkImageViewAddressPropertiesNVX pProperties_host;
37657
37658     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pProperties);
37659
37660     convert_VkImageViewAddressPropertiesNVX_win32_to_host(params->pProperties, &pProperties_host);
37661     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewAddressNVX(wine_device_from_handle(params->device)->device, params->imageView, &pProperties_host);
37662     convert_VkImageViewAddressPropertiesNVX_host_to_win32(&pProperties_host, params->pProperties);
37663     return STATUS_SUCCESS;
37664 }
37665
37666 #endif /* USE_STRUCT_CONVERSION */
37667
37668 #if !defined(USE_STRUCT_CONVERSION)
37669
37670 static NTSTATUS thunk64_vkGetImageViewHandleNVX(void *args)
37671 {
37672     struct vkGetImageViewHandleNVX_params *params = args;
37673
37674     TRACE("%p, %p\n", params->device, params->pInfo);
37675
37676     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewHandleNVX(wine_device_from_handle(params->device)->device, params->pInfo);
37677     return STATUS_SUCCESS;
37678 }
37679
37680 #else /* USE_STRUCT_CONVERSION */
37681
37682 static NTSTATUS thunk32_vkGetImageViewHandleNVX(void *args)
37683 {
37684     struct
37685     {
37686         VkDevice device;
37687         const VkImageViewHandleInfoNVX32 *pInfo;
37688         uint32_t result;
37689     } *params = args;
37690     VkImageViewHandleInfoNVX pInfo_host;
37691
37692     TRACE("%p, %p\n", params->device, params->pInfo);
37693
37694     convert_VkImageViewHandleInfoNVX_win32_to_host(params->pInfo, &pInfo_host);
37695     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewHandleNVX(wine_device_from_handle(params->device)->device, &pInfo_host);
37696     return STATUS_SUCCESS;
37697 }
37698
37699 #endif /* USE_STRUCT_CONVERSION */
37700
37701 #if !defined(USE_STRUCT_CONVERSION)
37702
37703 static NTSTATUS thunk64_vkGetMemoryHostPointerPropertiesEXT(void *args)
37704 {
37705     struct vkGetMemoryHostPointerPropertiesEXT_params *params = args;
37706
37707     TRACE("%p, %#x, %p, %p\n", params->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
37708
37709     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetMemoryHostPointerPropertiesEXT(wine_device_from_handle(params->device)->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
37710     return STATUS_SUCCESS;
37711 }
37712
37713 #else /* USE_STRUCT_CONVERSION */
37714
37715 static NTSTATUS thunk32_vkGetMemoryHostPointerPropertiesEXT(void *args)
37716 {
37717     struct
37718     {
37719         VkDevice device;
37720         VkExternalMemoryHandleTypeFlagBits handleType;
37721         const void *pHostPointer;
37722         VkMemoryHostPointerPropertiesEXT32 *pMemoryHostPointerProperties;
37723         VkResult result;
37724     } *params = args;
37725     VkMemoryHostPointerPropertiesEXT pMemoryHostPointerProperties_host;
37726
37727     TRACE("%p, %#x, %p, %p\n", params->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
37728
37729     convert_VkMemoryHostPointerPropertiesEXT_win32_to_host(params->pMemoryHostPointerProperties, &pMemoryHostPointerProperties_host);
37730     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetMemoryHostPointerPropertiesEXT(wine_device_from_handle(params->device)->device, params->handleType, params->pHostPointer, &pMemoryHostPointerProperties_host);
37731     convert_VkMemoryHostPointerPropertiesEXT_host_to_win32(&pMemoryHostPointerProperties_host, params->pMemoryHostPointerProperties);
37732     return STATUS_SUCCESS;
37733 }
37734
37735 #endif /* USE_STRUCT_CONVERSION */
37736
37737 #if !defined(USE_STRUCT_CONVERSION)
37738
37739 static NTSTATUS thunk64_vkGetMicromapBuildSizesEXT(void *args)
37740 {
37741     struct vkGetMicromapBuildSizesEXT_params *params = args;
37742
37743     TRACE("%p, %#x, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
37744
37745     wine_device_from_handle(params->device)->funcs.p_vkGetMicromapBuildSizesEXT(wine_device_from_handle(params->device)->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
37746     return STATUS_SUCCESS;
37747 }
37748
37749 #else /* USE_STRUCT_CONVERSION */
37750
37751 static NTSTATUS thunk32_vkGetMicromapBuildSizesEXT(void *args)
37752 {
37753     struct
37754     {
37755         VkDevice device;
37756         VkAccelerationStructureBuildTypeKHR buildType;
37757         const VkMicromapBuildInfoEXT32 *pBuildInfo;
37758         VkMicromapBuildSizesInfoEXT32 *pSizeInfo;
37759     } *params = args;
37760     VkMicromapBuildInfoEXT pBuildInfo_host;
37761     VkMicromapBuildSizesInfoEXT pSizeInfo_host;
37762
37763     TRACE("%p, %#x, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
37764
37765     convert_VkMicromapBuildInfoEXT_win32_to_host(params->pBuildInfo, &pBuildInfo_host);
37766     convert_VkMicromapBuildSizesInfoEXT_win32_to_host(params->pSizeInfo, &pSizeInfo_host);
37767     wine_device_from_handle(params->device)->funcs.p_vkGetMicromapBuildSizesEXT(wine_device_from_handle(params->device)->device, params->buildType, &pBuildInfo_host, &pSizeInfo_host);
37768     convert_VkMicromapBuildSizesInfoEXT_host_to_win32(&pSizeInfo_host, params->pSizeInfo);
37769     return STATUS_SUCCESS;
37770 }
37771
37772 #endif /* USE_STRUCT_CONVERSION */
37773
37774 #if !defined(USE_STRUCT_CONVERSION)
37775
37776 static NTSTATUS thunk64_vkGetPerformanceParameterINTEL(void *args)
37777 {
37778     struct vkGetPerformanceParameterINTEL_params *params = args;
37779
37780     TRACE("%p, %#x, %p\n", params->device, params->parameter, params->pValue);
37781
37782     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPerformanceParameterINTEL(wine_device_from_handle(params->device)->device, params->parameter, params->pValue);
37783     return STATUS_SUCCESS;
37784 }
37785
37786 #else /* USE_STRUCT_CONVERSION */
37787
37788 static NTSTATUS thunk32_vkGetPerformanceParameterINTEL(void *args)
37789 {
37790     struct
37791     {
37792         VkDevice device;
37793         VkPerformanceParameterTypeINTEL parameter;
37794         VkPerformanceValueINTEL32 *pValue;
37795         VkResult result;
37796     } *params = args;
37797     VkPerformanceValueINTEL pValue_host;
37798
37799     TRACE("%p, %#x, %p\n", params->device, params->parameter, params->pValue);
37800
37801     convert_VkPerformanceValueINTEL_win32_to_host(params->pValue, &pValue_host);
37802     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPerformanceParameterINTEL(wine_device_from_handle(params->device)->device, params->parameter, &pValue_host);
37803     convert_VkPerformanceValueINTEL_host_to_win32(&pValue_host, params->pValue);
37804     return STATUS_SUCCESS;
37805 }
37806
37807 #endif /* USE_STRUCT_CONVERSION */
37808
37809 #if !defined(USE_STRUCT_CONVERSION)
37810
37811 static NTSTATUS thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *args)
37812 {
37813     struct vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_params *params = args;
37814
37815     TRACE("%p, %p, %p\n", params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
37816
37817     params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
37818     return STATUS_SUCCESS;
37819 }
37820
37821 #else /* USE_STRUCT_CONVERSION */
37822
37823 static NTSTATUS thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *args)
37824 {
37825     struct
37826     {
37827         VkPhysicalDevice physicalDevice;
37828         uint32_t *pTimeDomainCount;
37829         VkTimeDomainEXT *pTimeDomains;
37830         VkResult result;
37831     } *params = args;
37832
37833     TRACE("%p, %p, %p\n", params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
37834
37835     params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
37836     return STATUS_SUCCESS;
37837 }
37838
37839 #endif /* USE_STRUCT_CONVERSION */
37840
37841 #if !defined(USE_STRUCT_CONVERSION)
37842
37843 static NTSTATUS thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(void *args)
37844 {
37845     struct vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_params *params = args;
37846
37847     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
37848
37849     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pPropertyCount, params->pProperties);
37850     return STATUS_SUCCESS;
37851 }
37852
37853 #else /* USE_STRUCT_CONVERSION */
37854
37855 static NTSTATUS thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(void *args)
37856 {
37857     struct
37858     {
37859         VkPhysicalDevice physicalDevice;
37860         uint32_t *pPropertyCount;
37861         VkCooperativeMatrixPropertiesNV32 *pProperties;
37862         VkResult result;
37863     } *params = args;
37864     VkCooperativeMatrixPropertiesNV *pProperties_host;
37865     struct conversion_context ctx;
37866
37867     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
37868
37869     init_conversion_context(&ctx);
37870     pProperties_host = convert_VkCooperativeMatrixPropertiesNV_array_win32_to_host(&ctx, params->pProperties, *params->pPropertyCount);
37871     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pPropertyCount, pProperties_host);
37872     convert_VkCooperativeMatrixPropertiesNV_array_host_to_win32(pProperties_host, params->pProperties, *params->pPropertyCount);
37873     free_conversion_context(&ctx);
37874     return STATUS_SUCCESS;
37875 }
37876
37877 #endif /* USE_STRUCT_CONVERSION */
37878
37879 #if !defined(USE_STRUCT_CONVERSION)
37880
37881 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalBufferProperties(void *args)
37882 {
37883     struct vkGetPhysicalDeviceExternalBufferProperties_params *params = args;
37884
37885     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37886
37887     wine_vkGetPhysicalDeviceExternalBufferProperties(params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37888     return STATUS_SUCCESS;
37889 }
37890
37891 #else /* USE_STRUCT_CONVERSION */
37892
37893 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalBufferProperties(void *args)
37894 {
37895     struct
37896     {
37897         VkPhysicalDevice physicalDevice;
37898         const VkPhysicalDeviceExternalBufferInfo32 *pExternalBufferInfo;
37899         VkExternalBufferProperties32 *pExternalBufferProperties;
37900     } *params = args;
37901     VkPhysicalDeviceExternalBufferInfo pExternalBufferInfo_host;
37902     VkExternalBufferProperties pExternalBufferProperties_host;
37903
37904     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37905
37906     convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(params->pExternalBufferInfo, &pExternalBufferInfo_host);
37907     convert_VkExternalBufferProperties_win32_to_host(params->pExternalBufferProperties, &pExternalBufferProperties_host);
37908     wine_vkGetPhysicalDeviceExternalBufferProperties(params->physicalDevice, &pExternalBufferInfo_host, &pExternalBufferProperties_host);
37909     convert_VkExternalBufferProperties_host_to_win32(&pExternalBufferProperties_host, params->pExternalBufferProperties);
37910     return STATUS_SUCCESS;
37911 }
37912
37913 #endif /* USE_STRUCT_CONVERSION */
37914
37915 #if !defined(USE_STRUCT_CONVERSION)
37916
37917 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalBufferPropertiesKHR(void *args)
37918 {
37919     struct vkGetPhysicalDeviceExternalBufferPropertiesKHR_params *params = args;
37920
37921     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37922
37923     wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37924     return STATUS_SUCCESS;
37925 }
37926
37927 #else /* USE_STRUCT_CONVERSION */
37928
37929 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalBufferPropertiesKHR(void *args)
37930 {
37931     struct
37932     {
37933         VkPhysicalDevice physicalDevice;
37934         const VkPhysicalDeviceExternalBufferInfo32 *pExternalBufferInfo;
37935         VkExternalBufferProperties32 *pExternalBufferProperties;
37936     } *params = args;
37937     VkPhysicalDeviceExternalBufferInfo pExternalBufferInfo_host;
37938     VkExternalBufferProperties pExternalBufferProperties_host;
37939
37940     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37941
37942     convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(params->pExternalBufferInfo, &pExternalBufferInfo_host);
37943     convert_VkExternalBufferProperties_win32_to_host(params->pExternalBufferProperties, &pExternalBufferProperties_host);
37944     wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(params->physicalDevice, &pExternalBufferInfo_host, &pExternalBufferProperties_host);
37945     convert_VkExternalBufferProperties_host_to_win32(&pExternalBufferProperties_host, params->pExternalBufferProperties);
37946     return STATUS_SUCCESS;
37947 }
37948
37949 #endif /* USE_STRUCT_CONVERSION */
37950
37951 #if !defined(USE_STRUCT_CONVERSION)
37952
37953 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalFenceProperties(void *args)
37954 {
37955     struct vkGetPhysicalDeviceExternalFenceProperties_params *params = args;
37956
37957     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
37958
37959     wine_vkGetPhysicalDeviceExternalFenceProperties(params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
37960     return STATUS_SUCCESS;
37961 }
37962
37963 #else /* USE_STRUCT_CONVERSION */
37964
37965 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalFenceProperties(void *args)
37966 {
37967     struct
37968     {
37969         VkPhysicalDevice physicalDevice;
37970         const VkPhysicalDeviceExternalFenceInfo32 *pExternalFenceInfo;
37971         VkExternalFenceProperties32 *pExternalFenceProperties;
37972     } *params = args;
37973     VkPhysicalDeviceExternalFenceInfo pExternalFenceInfo_host;
37974     VkExternalFenceProperties pExternalFenceProperties_host;
37975
37976     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
37977
37978     convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host(params->pExternalFenceInfo, &pExternalFenceInfo_host);
37979     convert_VkExternalFenceProperties_win32_to_host(params->pExternalFenceProperties, &pExternalFenceProperties_host);
37980     wine_vkGetPhysicalDeviceExternalFenceProperties(params->physicalDevice, &pExternalFenceInfo_host, &pExternalFenceProperties_host);
37981     convert_VkExternalFenceProperties_host_to_win32(&pExternalFenceProperties_host, params->pExternalFenceProperties);
37982     return STATUS_SUCCESS;
37983 }
37984
37985 #endif /* USE_STRUCT_CONVERSION */
37986
37987 #if !defined(USE_STRUCT_CONVERSION)
37988
37989 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalFencePropertiesKHR(void *args)
37990 {
37991     struct vkGetPhysicalDeviceExternalFencePropertiesKHR_params *params = args;
37992
37993     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
37994
37995     wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
37996     return STATUS_SUCCESS;
37997 }
37998
37999 #else /* USE_STRUCT_CONVERSION */
38000
38001 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalFencePropertiesKHR(void *args)
38002 {
38003     struct
38004     {
38005         VkPhysicalDevice physicalDevice;
38006         const VkPhysicalDeviceExternalFenceInfo32 *pExternalFenceInfo;
38007         VkExternalFenceProperties32 *pExternalFenceProperties;
38008     } *params = args;
38009     VkPhysicalDeviceExternalFenceInfo pExternalFenceInfo_host;
38010     VkExternalFenceProperties pExternalFenceProperties_host;
38011
38012     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
38013
38014     convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host(params->pExternalFenceInfo, &pExternalFenceInfo_host);
38015     convert_VkExternalFenceProperties_win32_to_host(params->pExternalFenceProperties, &pExternalFenceProperties_host);
38016     wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(params->physicalDevice, &pExternalFenceInfo_host, &pExternalFenceProperties_host);
38017     convert_VkExternalFenceProperties_host_to_win32(&pExternalFenceProperties_host, params->pExternalFenceProperties);
38018     return STATUS_SUCCESS;
38019 }
38020
38021 #endif /* USE_STRUCT_CONVERSION */
38022
38023 #if !defined(USE_STRUCT_CONVERSION)
38024
38025 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalSemaphoreProperties(void *args)
38026 {
38027     struct vkGetPhysicalDeviceExternalSemaphoreProperties_params *params = args;
38028
38029     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
38030
38031     wine_vkGetPhysicalDeviceExternalSemaphoreProperties(params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
38032     return STATUS_SUCCESS;
38033 }
38034
38035 #else /* USE_STRUCT_CONVERSION */
38036
38037 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalSemaphoreProperties(void *args)
38038 {
38039     struct
38040     {
38041         VkPhysicalDevice physicalDevice;
38042         const VkPhysicalDeviceExternalSemaphoreInfo32 *pExternalSemaphoreInfo;
38043         VkExternalSemaphoreProperties32 *pExternalSemaphoreProperties;
38044     } *params = args;
38045     VkPhysicalDeviceExternalSemaphoreInfo pExternalSemaphoreInfo_host;
38046     VkExternalSemaphoreProperties pExternalSemaphoreProperties_host;
38047     struct conversion_context ctx;
38048
38049     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
38050
38051     init_conversion_context(&ctx);
38052     convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(&ctx, params->pExternalSemaphoreInfo, &pExternalSemaphoreInfo_host);
38053     convert_VkExternalSemaphoreProperties_win32_to_host(params->pExternalSemaphoreProperties, &pExternalSemaphoreProperties_host);
38054     wine_vkGetPhysicalDeviceExternalSemaphoreProperties(params->physicalDevice, &pExternalSemaphoreInfo_host, &pExternalSemaphoreProperties_host);
38055     convert_VkExternalSemaphoreProperties_host_to_win32(&pExternalSemaphoreProperties_host, params->pExternalSemaphoreProperties);
38056     free_conversion_context(&ctx);
38057     return STATUS_SUCCESS;
38058 }
38059
38060 #endif /* USE_STRUCT_CONVERSION */
38061
38062 #if !defined(USE_STRUCT_CONVERSION)
38063
38064 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(void *args)
38065 {
38066     struct vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_params *params = args;
38067
38068     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
38069
38070     wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
38071     return STATUS_SUCCESS;
38072 }
38073
38074 #else /* USE_STRUCT_CONVERSION */
38075
38076 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(void *args)
38077 {
38078     struct
38079     {
38080         VkPhysicalDevice physicalDevice;
38081         const VkPhysicalDeviceExternalSemaphoreInfo32 *pExternalSemaphoreInfo;
38082         VkExternalSemaphoreProperties32 *pExternalSemaphoreProperties;
38083     } *params = args;
38084     VkPhysicalDeviceExternalSemaphoreInfo pExternalSemaphoreInfo_host;
38085     VkExternalSemaphoreProperties pExternalSemaphoreProperties_host;
38086     struct conversion_context ctx;
38087
38088     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
38089
38090     init_conversion_context(&ctx);
38091     convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(&ctx, params->pExternalSemaphoreInfo, &pExternalSemaphoreInfo_host);
38092     convert_VkExternalSemaphoreProperties_win32_to_host(params->pExternalSemaphoreProperties, &pExternalSemaphoreProperties_host);
38093     wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(params->physicalDevice, &pExternalSemaphoreInfo_host, &pExternalSemaphoreProperties_host);
38094     convert_VkExternalSemaphoreProperties_host_to_win32(&pExternalSemaphoreProperties_host, params->pExternalSemaphoreProperties);
38095     free_conversion_context(&ctx);
38096     return STATUS_SUCCESS;
38097 }
38098
38099 #endif /* USE_STRUCT_CONVERSION */
38100
38101 #if !defined(USE_STRUCT_CONVERSION)
38102
38103 static NTSTATUS thunk64_vkGetPhysicalDeviceFeatures(void *args)
38104 {
38105     struct vkGetPhysicalDeviceFeatures_params *params = args;
38106
38107     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
38108
38109     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
38110     return STATUS_SUCCESS;
38111 }
38112
38113 #else /* USE_STRUCT_CONVERSION */
38114
38115 static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures(void *args)
38116 {
38117     struct
38118     {
38119         VkPhysicalDevice physicalDevice;
38120         VkPhysicalDeviceFeatures *pFeatures;
38121     } *params = args;
38122
38123     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
38124
38125     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
38126     return STATUS_SUCCESS;
38127 }
38128
38129 #endif /* USE_STRUCT_CONVERSION */
38130
38131 #if !defined(USE_STRUCT_CONVERSION)
38132
38133 static NTSTATUS thunk64_vkGetPhysicalDeviceFeatures2(void *args)
38134 {
38135     struct vkGetPhysicalDeviceFeatures2_params *params = args;
38136
38137     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
38138
38139     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
38140     return STATUS_SUCCESS;
38141 }
38142
38143 #else /* USE_STRUCT_CONVERSION */
38144
38145 static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures2(void *args)
38146 {
38147     struct
38148     {
38149         VkPhysicalDevice physicalDevice;
38150         VkPhysicalDeviceFeatures232 *pFeatures;
38151     } *params = args;
38152     VkPhysicalDeviceFeatures2 pFeatures_host;
38153     struct conversion_context ctx;
38154
38155     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
38156
38157     init_conversion_context(&ctx);
38158     convert_VkPhysicalDeviceFeatures2_win32_to_host(&ctx, params->pFeatures, &pFeatures_host);
38159     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pFeatures_host);
38160     convert_VkPhysicalDeviceFeatures2_host_to_win32(&pFeatures_host, params->pFeatures);
38161     free_conversion_context(&ctx);
38162     return STATUS_SUCCESS;
38163 }
38164
38165 #endif /* USE_STRUCT_CONVERSION */
38166
38167 #if !defined(USE_STRUCT_CONVERSION)
38168
38169 static NTSTATUS thunk64_vkGetPhysicalDeviceFeatures2KHR(void *args)
38170 {
38171     struct vkGetPhysicalDeviceFeatures2KHR_params *params = args;
38172
38173     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
38174
38175     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
38176     return STATUS_SUCCESS;
38177 }
38178
38179 #else /* USE_STRUCT_CONVERSION */
38180
38181 static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures2KHR(void *args)
38182 {
38183     struct
38184     {
38185         VkPhysicalDevice physicalDevice;
38186         VkPhysicalDeviceFeatures232 *pFeatures;
38187     } *params = args;
38188     VkPhysicalDeviceFeatures2 pFeatures_host;
38189     struct conversion_context ctx;
38190
38191     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
38192
38193     init_conversion_context(&ctx);
38194     convert_VkPhysicalDeviceFeatures2_win32_to_host(&ctx, params->pFeatures, &pFeatures_host);
38195     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pFeatures_host);
38196     convert_VkPhysicalDeviceFeatures2_host_to_win32(&pFeatures_host, params->pFeatures);
38197     free_conversion_context(&ctx);
38198     return STATUS_SUCCESS;
38199 }
38200
38201 #endif /* USE_STRUCT_CONVERSION */
38202
38203 #if !defined(USE_STRUCT_CONVERSION)
38204
38205 static NTSTATUS thunk64_vkGetPhysicalDeviceFormatProperties(void *args)
38206 {
38207     struct vkGetPhysicalDeviceFormatProperties_params *params = args;
38208
38209     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
38210
38211     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
38212     return STATUS_SUCCESS;
38213 }
38214
38215 #else /* USE_STRUCT_CONVERSION */
38216
38217 static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties(void *args)
38218 {
38219     struct
38220     {
38221         VkPhysicalDevice physicalDevice;
38222         VkFormat format;
38223         VkFormatProperties *pFormatProperties;
38224     } *params = args;
38225
38226     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
38227
38228     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
38229     return STATUS_SUCCESS;
38230 }
38231
38232 #endif /* USE_STRUCT_CONVERSION */
38233
38234 #if !defined(USE_STRUCT_CONVERSION)
38235
38236 static NTSTATUS thunk64_vkGetPhysicalDeviceFormatProperties2(void *args)
38237 {
38238     struct vkGetPhysicalDeviceFormatProperties2_params *params = args;
38239
38240     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
38241
38242     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
38243     return STATUS_SUCCESS;
38244 }
38245
38246 #else /* USE_STRUCT_CONVERSION */
38247
38248 static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties2(void *args)
38249 {
38250     struct
38251     {
38252         VkPhysicalDevice physicalDevice;
38253         VkFormat format;
38254         VkFormatProperties232 *pFormatProperties;
38255     } *params = args;
38256     VkFormatProperties2 pFormatProperties_host;
38257     struct conversion_context ctx;
38258
38259     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
38260
38261     init_conversion_context(&ctx);
38262     convert_VkFormatProperties2_win32_to_host(&ctx, params->pFormatProperties, &pFormatProperties_host);
38263     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, &pFormatProperties_host);
38264     convert_VkFormatProperties2_host_to_win32(&pFormatProperties_host, params->pFormatProperties);
38265     free_conversion_context(&ctx);
38266     return STATUS_SUCCESS;
38267 }
38268
38269 #endif /* USE_STRUCT_CONVERSION */
38270
38271 #if !defined(USE_STRUCT_CONVERSION)
38272
38273 static NTSTATUS thunk64_vkGetPhysicalDeviceFormatProperties2KHR(void *args)
38274 {
38275     struct vkGetPhysicalDeviceFormatProperties2KHR_params *params = args;
38276
38277     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
38278
38279     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
38280     return STATUS_SUCCESS;
38281 }
38282
38283 #else /* USE_STRUCT_CONVERSION */
38284
38285 static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties2KHR(void *args)
38286 {
38287     struct
38288     {
38289         VkPhysicalDevice physicalDevice;
38290         VkFormat format;
38291         VkFormatProperties232 *pFormatProperties;
38292     } *params = args;
38293     VkFormatProperties2 pFormatProperties_host;
38294     struct conversion_context ctx;
38295
38296     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
38297
38298     init_conversion_context(&ctx);
38299     convert_VkFormatProperties2_win32_to_host(&ctx, params->pFormatProperties, &pFormatProperties_host);
38300     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, &pFormatProperties_host);
38301     convert_VkFormatProperties2_host_to_win32(&pFormatProperties_host, params->pFormatProperties);
38302     free_conversion_context(&ctx);
38303     return STATUS_SUCCESS;
38304 }
38305
38306 #endif /* USE_STRUCT_CONVERSION */
38307
38308 #if !defined(USE_STRUCT_CONVERSION)
38309
38310 static NTSTATUS thunk64_vkGetPhysicalDeviceFragmentShadingRatesKHR(void *args)
38311 {
38312     struct vkGetPhysicalDeviceFragmentShadingRatesKHR_params *params = args;
38313
38314     TRACE("%p, %p, %p\n", params->physicalDevice, params->pFragmentShadingRateCount, params->pFragmentShadingRates);
38315
38316     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFragmentShadingRatesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFragmentShadingRateCount, params->pFragmentShadingRates);
38317     return STATUS_SUCCESS;
38318 }
38319
38320 #else /* USE_STRUCT_CONVERSION */
38321
38322 static NTSTATUS thunk32_vkGetPhysicalDeviceFragmentShadingRatesKHR(void *args)
38323 {
38324     struct
38325     {
38326         VkPhysicalDevice physicalDevice;
38327         uint32_t *pFragmentShadingRateCount;
38328         VkPhysicalDeviceFragmentShadingRateKHR32 *pFragmentShadingRates;
38329         VkResult result;
38330     } *params = args;
38331     VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates_host;
38332     struct conversion_context ctx;
38333
38334     TRACE("%p, %p, %p\n", params->physicalDevice, params->pFragmentShadingRateCount, params->pFragmentShadingRates);
38335
38336     init_conversion_context(&ctx);
38337     pFragmentShadingRates_host = convert_VkPhysicalDeviceFragmentShadingRateKHR_array_win32_to_host(&ctx, params->pFragmentShadingRates, *params->pFragmentShadingRateCount);
38338     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFragmentShadingRatesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFragmentShadingRateCount, pFragmentShadingRates_host);
38339     convert_VkPhysicalDeviceFragmentShadingRateKHR_array_host_to_win32(pFragmentShadingRates_host, params->pFragmentShadingRates, *params->pFragmentShadingRateCount);
38340     free_conversion_context(&ctx);
38341     return STATUS_SUCCESS;
38342 }
38343
38344 #endif /* USE_STRUCT_CONVERSION */
38345
38346 #if !defined(USE_STRUCT_CONVERSION)
38347
38348 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties(void *args)
38349 {
38350     struct vkGetPhysicalDeviceImageFormatProperties_params *params = args;
38351
38352     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p\n", params->physicalDevice, params->format, params->type, params->tiling, params->usage, params->flags, params->pImageFormatProperties);
38353
38354     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->type, params->tiling, params->usage, params->flags, params->pImageFormatProperties);
38355     return STATUS_SUCCESS;
38356 }
38357
38358 #else /* USE_STRUCT_CONVERSION */
38359
38360 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties(void *args)
38361 {
38362     struct
38363     {
38364         VkPhysicalDevice physicalDevice;
38365         VkFormat format;
38366         VkImageType type;
38367         VkImageTiling tiling;
38368         VkImageUsageFlags usage;
38369         VkImageCreateFlags flags;
38370         VkImageFormatProperties32 *pImageFormatProperties;
38371         VkResult result;
38372     } *params = args;
38373     VkImageFormatProperties pImageFormatProperties_host;
38374
38375     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p\n", params->physicalDevice, params->format, params->type, params->tiling, params->usage, params->flags, params->pImageFormatProperties);
38376
38377     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->type, params->tiling, params->usage, params->flags, &pImageFormatProperties_host);
38378     convert_VkImageFormatProperties_host_to_win32(&pImageFormatProperties_host, params->pImageFormatProperties);
38379     return STATUS_SUCCESS;
38380 }
38381
38382 #endif /* USE_STRUCT_CONVERSION */
38383
38384 #if !defined(USE_STRUCT_CONVERSION)
38385
38386 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties2(void *args)
38387 {
38388     struct vkGetPhysicalDeviceImageFormatProperties2_params *params = args;
38389
38390     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
38391
38392     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
38393     return STATUS_SUCCESS;
38394 }
38395
38396 #else /* USE_STRUCT_CONVERSION */
38397
38398 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties2(void *args)
38399 {
38400     struct
38401     {
38402         VkPhysicalDevice physicalDevice;
38403         const VkPhysicalDeviceImageFormatInfo232 *pImageFormatInfo;
38404         VkImageFormatProperties232 *pImageFormatProperties;
38405         VkResult result;
38406     } *params = args;
38407     VkPhysicalDeviceImageFormatInfo2 pImageFormatInfo_host;
38408     VkImageFormatProperties2 pImageFormatProperties_host;
38409     struct conversion_context ctx;
38410
38411     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
38412
38413     init_conversion_context(&ctx);
38414     convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(&ctx, params->pImageFormatInfo, &pImageFormatInfo_host);
38415     convert_VkImageFormatProperties2_win32_to_host(&ctx, params->pImageFormatProperties, &pImageFormatProperties_host);
38416     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2(params->physicalDevice, &pImageFormatInfo_host, &pImageFormatProperties_host);
38417     convert_VkImageFormatProperties2_host_to_win32(&pImageFormatProperties_host, params->pImageFormatProperties);
38418     free_conversion_context(&ctx);
38419     return STATUS_SUCCESS;
38420 }
38421
38422 #endif /* USE_STRUCT_CONVERSION */
38423
38424 #if !defined(USE_STRUCT_CONVERSION)
38425
38426 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties2KHR(void *args)
38427 {
38428     struct vkGetPhysicalDeviceImageFormatProperties2KHR_params *params = args;
38429
38430     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
38431
38432     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
38433     return STATUS_SUCCESS;
38434 }
38435
38436 #else /* USE_STRUCT_CONVERSION */
38437
38438 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties2KHR(void *args)
38439 {
38440     struct
38441     {
38442         VkPhysicalDevice physicalDevice;
38443         const VkPhysicalDeviceImageFormatInfo232 *pImageFormatInfo;
38444         VkImageFormatProperties232 *pImageFormatProperties;
38445         VkResult result;
38446     } *params = args;
38447     VkPhysicalDeviceImageFormatInfo2 pImageFormatInfo_host;
38448     VkImageFormatProperties2 pImageFormatProperties_host;
38449     struct conversion_context ctx;
38450
38451     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
38452
38453     init_conversion_context(&ctx);
38454     convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(&ctx, params->pImageFormatInfo, &pImageFormatInfo_host);
38455     convert_VkImageFormatProperties2_win32_to_host(&ctx, params->pImageFormatProperties, &pImageFormatProperties_host);
38456     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR(params->physicalDevice, &pImageFormatInfo_host, &pImageFormatProperties_host);
38457     convert_VkImageFormatProperties2_host_to_win32(&pImageFormatProperties_host, params->pImageFormatProperties);
38458     free_conversion_context(&ctx);
38459     return STATUS_SUCCESS;
38460 }
38461
38462 #endif /* USE_STRUCT_CONVERSION */
38463
38464 #if !defined(USE_STRUCT_CONVERSION)
38465
38466 static NTSTATUS thunk64_vkGetPhysicalDeviceMemoryProperties(void *args)
38467 {
38468     struct vkGetPhysicalDeviceMemoryProperties_params *params = args;
38469
38470     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
38471
38472     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pMemoryProperties);
38473     return STATUS_SUCCESS;
38474 }
38475
38476 #else /* USE_STRUCT_CONVERSION */
38477
38478 static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties(void *args)
38479 {
38480     struct
38481     {
38482         VkPhysicalDevice physicalDevice;
38483         VkPhysicalDeviceMemoryProperties32 *pMemoryProperties;
38484     } *params = args;
38485     VkPhysicalDeviceMemoryProperties pMemoryProperties_host;
38486
38487     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
38488
38489     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pMemoryProperties_host);
38490     convert_VkPhysicalDeviceMemoryProperties_host_to_win32(&pMemoryProperties_host, params->pMemoryProperties);
38491     return STATUS_SUCCESS;
38492 }
38493
38494 #endif /* USE_STRUCT_CONVERSION */
38495
38496 #if !defined(USE_STRUCT_CONVERSION)
38497
38498 static NTSTATUS thunk64_vkGetPhysicalDeviceMemoryProperties2(void *args)
38499 {
38500     struct vkGetPhysicalDeviceMemoryProperties2_params *params = args;
38501
38502     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
38503
38504     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pMemoryProperties);
38505     return STATUS_SUCCESS;
38506 }
38507
38508 #else /* USE_STRUCT_CONVERSION */
38509
38510 static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties2(void *args)
38511 {
38512     struct
38513     {
38514         VkPhysicalDevice physicalDevice;
38515         VkPhysicalDeviceMemoryProperties232 *pMemoryProperties;
38516     } *params = args;
38517     VkPhysicalDeviceMemoryProperties2 pMemoryProperties_host;
38518     struct conversion_context ctx;
38519
38520     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
38521
38522     init_conversion_context(&ctx);
38523     convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(&ctx, params->pMemoryProperties, &pMemoryProperties_host);
38524     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pMemoryProperties_host);
38525     convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(&pMemoryProperties_host, params->pMemoryProperties);
38526     free_conversion_context(&ctx);
38527     return STATUS_SUCCESS;
38528 }
38529
38530 #endif /* USE_STRUCT_CONVERSION */
38531
38532 #if !defined(USE_STRUCT_CONVERSION)
38533
38534 static NTSTATUS thunk64_vkGetPhysicalDeviceMemoryProperties2KHR(void *args)
38535 {
38536     struct vkGetPhysicalDeviceMemoryProperties2KHR_params *params = args;
38537
38538     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
38539
38540     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pMemoryProperties);
38541     return STATUS_SUCCESS;
38542 }
38543
38544 #else /* USE_STRUCT_CONVERSION */
38545
38546 static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties2KHR(void *args)
38547 {
38548     struct
38549     {
38550         VkPhysicalDevice physicalDevice;
38551         VkPhysicalDeviceMemoryProperties232 *pMemoryProperties;
38552     } *params = args;
38553     VkPhysicalDeviceMemoryProperties2 pMemoryProperties_host;
38554     struct conversion_context ctx;
38555
38556     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
38557
38558     init_conversion_context(&ctx);
38559     convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(&ctx, params->pMemoryProperties, &pMemoryProperties_host);
38560     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pMemoryProperties_host);
38561     convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(&pMemoryProperties_host, params->pMemoryProperties);
38562     free_conversion_context(&ctx);
38563     return STATUS_SUCCESS;
38564 }
38565
38566 #endif /* USE_STRUCT_CONVERSION */
38567
38568 #if !defined(USE_STRUCT_CONVERSION)
38569
38570 static NTSTATUS thunk64_vkGetPhysicalDeviceMultisamplePropertiesEXT(void *args)
38571 {
38572     struct vkGetPhysicalDeviceMultisamplePropertiesEXT_params *params = args;
38573
38574     TRACE("%p, %#x, %p\n", params->physicalDevice, params->samples, params->pMultisampleProperties);
38575
38576     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMultisamplePropertiesEXT(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->samples, params->pMultisampleProperties);
38577     return STATUS_SUCCESS;
38578 }
38579
38580 #else /* USE_STRUCT_CONVERSION */
38581
38582 static NTSTATUS thunk32_vkGetPhysicalDeviceMultisamplePropertiesEXT(void *args)
38583 {
38584     struct
38585     {
38586         VkPhysicalDevice physicalDevice;
38587         VkSampleCountFlagBits samples;
38588         VkMultisamplePropertiesEXT32 *pMultisampleProperties;
38589     } *params = args;
38590     VkMultisamplePropertiesEXT pMultisampleProperties_host;
38591
38592     TRACE("%p, %#x, %p\n", params->physicalDevice, params->samples, params->pMultisampleProperties);
38593
38594     convert_VkMultisamplePropertiesEXT_win32_to_host(params->pMultisampleProperties, &pMultisampleProperties_host);
38595     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMultisamplePropertiesEXT(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->samples, &pMultisampleProperties_host);
38596     convert_VkMultisamplePropertiesEXT_host_to_win32(&pMultisampleProperties_host, params->pMultisampleProperties);
38597     return STATUS_SUCCESS;
38598 }
38599
38600 #endif /* USE_STRUCT_CONVERSION */
38601
38602 #if !defined(USE_STRUCT_CONVERSION)
38603
38604 static NTSTATUS thunk64_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(void *args)
38605 {
38606     struct vkGetPhysicalDeviceOpticalFlowImageFormatsNV_params *params = args;
38607
38608     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pOpticalFlowImageFormatInfo, params->pFormatCount, params->pImageFormatProperties);
38609
38610     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pOpticalFlowImageFormatInfo, params->pFormatCount, params->pImageFormatProperties);
38611     return STATUS_SUCCESS;
38612 }
38613
38614 #else /* USE_STRUCT_CONVERSION */
38615
38616 static NTSTATUS thunk32_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(void *args)
38617 {
38618     struct
38619     {
38620         VkPhysicalDevice physicalDevice;
38621         const VkOpticalFlowImageFormatInfoNV32 *pOpticalFlowImageFormatInfo;
38622         uint32_t *pFormatCount;
38623         VkOpticalFlowImageFormatPropertiesNV32 *pImageFormatProperties;
38624         VkResult result;
38625     } *params = args;
38626     VkOpticalFlowImageFormatInfoNV pOpticalFlowImageFormatInfo_host;
38627     VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties_host;
38628     struct conversion_context ctx;
38629
38630     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pOpticalFlowImageFormatInfo, params->pFormatCount, params->pImageFormatProperties);
38631
38632     init_conversion_context(&ctx);
38633     convert_VkOpticalFlowImageFormatInfoNV_win32_to_host(params->pOpticalFlowImageFormatInfo, &pOpticalFlowImageFormatInfo_host);
38634     pImageFormatProperties_host = convert_VkOpticalFlowImageFormatPropertiesNV_array_win32_to_host(&ctx, params->pImageFormatProperties, *params->pFormatCount);
38635     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pOpticalFlowImageFormatInfo_host, params->pFormatCount, pImageFormatProperties_host);
38636     convert_VkOpticalFlowImageFormatPropertiesNV_array_host_to_win32(pImageFormatProperties_host, params->pImageFormatProperties, *params->pFormatCount);
38637     free_conversion_context(&ctx);
38638     return STATUS_SUCCESS;
38639 }
38640
38641 #endif /* USE_STRUCT_CONVERSION */
38642
38643 #if !defined(USE_STRUCT_CONVERSION)
38644
38645 static NTSTATUS thunk64_vkGetPhysicalDevicePresentRectanglesKHR(void *args)
38646 {
38647     struct vkGetPhysicalDevicePresentRectanglesKHR_params *params = args;
38648
38649     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pRectCount, params->pRects);
38650
38651     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDevicePresentRectanglesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pRectCount, params->pRects);
38652     return STATUS_SUCCESS;
38653 }
38654
38655 #else /* USE_STRUCT_CONVERSION */
38656
38657 static NTSTATUS thunk32_vkGetPhysicalDevicePresentRectanglesKHR(void *args)
38658 {
38659     struct
38660     {
38661         VkPhysicalDevice physicalDevice;
38662         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
38663         uint32_t *pRectCount;
38664         VkRect2D *pRects;
38665         VkResult result;
38666     } *params = args;
38667
38668     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pRectCount, params->pRects);
38669
38670     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDevicePresentRectanglesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pRectCount, params->pRects);
38671     return STATUS_SUCCESS;
38672 }
38673
38674 #endif /* USE_STRUCT_CONVERSION */
38675
38676 #if !defined(USE_STRUCT_CONVERSION)
38677
38678 static NTSTATUS thunk64_vkGetPhysicalDeviceProperties(void *args)
38679 {
38680     struct vkGetPhysicalDeviceProperties_params *params = args;
38681
38682     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
38683
38684     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pProperties);
38685     return STATUS_SUCCESS;
38686 }
38687
38688 #else /* USE_STRUCT_CONVERSION */
38689
38690 static NTSTATUS thunk32_vkGetPhysicalDeviceProperties(void *args)
38691 {
38692     struct
38693     {
38694         VkPhysicalDevice physicalDevice;
38695         VkPhysicalDeviceProperties32 *pProperties;
38696     } *params = args;
38697     VkPhysicalDeviceProperties pProperties_host;
38698
38699     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
38700
38701     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pProperties_host);
38702     convert_VkPhysicalDeviceProperties_host_to_win32(&pProperties_host, params->pProperties);
38703     return STATUS_SUCCESS;
38704 }
38705
38706 #endif /* USE_STRUCT_CONVERSION */
38707
38708 #if !defined(USE_STRUCT_CONVERSION)
38709
38710 static NTSTATUS thunk64_vkGetPhysicalDeviceProperties2(void *args)
38711 {
38712     struct vkGetPhysicalDeviceProperties2_params *params = args;
38713
38714     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
38715
38716     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pProperties);
38717     return STATUS_SUCCESS;
38718 }
38719
38720 #else /* USE_STRUCT_CONVERSION */
38721
38722 static NTSTATUS thunk32_vkGetPhysicalDeviceProperties2(void *args)
38723 {
38724     struct
38725     {
38726         VkPhysicalDevice physicalDevice;
38727         VkPhysicalDeviceProperties232 *pProperties;
38728     } *params = args;
38729     VkPhysicalDeviceProperties2 pProperties_host;
38730     struct conversion_context ctx;
38731
38732     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
38733
38734     init_conversion_context(&ctx);
38735     convert_VkPhysicalDeviceProperties2_win32_to_host(&ctx, params->pProperties, &pProperties_host);
38736     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pProperties_host);
38737     convert_VkPhysicalDeviceProperties2_host_to_win32(&pProperties_host, params->pProperties);
38738     free_conversion_context(&ctx);
38739     return STATUS_SUCCESS;
38740 }
38741
38742 #endif /* USE_STRUCT_CONVERSION */
38743
38744 #if !defined(USE_STRUCT_CONVERSION)
38745
38746 static NTSTATUS thunk64_vkGetPhysicalDeviceProperties2KHR(void *args)
38747 {
38748     struct vkGetPhysicalDeviceProperties2KHR_params *params = args;
38749
38750     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
38751
38752     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pProperties);
38753     return STATUS_SUCCESS;
38754 }
38755
38756 #else /* USE_STRUCT_CONVERSION */
38757
38758 static NTSTATUS thunk32_vkGetPhysicalDeviceProperties2KHR(void *args)
38759 {
38760     struct
38761     {
38762         VkPhysicalDevice physicalDevice;
38763         VkPhysicalDeviceProperties232 *pProperties;
38764     } *params = args;
38765     VkPhysicalDeviceProperties2 pProperties_host;
38766     struct conversion_context ctx;
38767
38768     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
38769
38770     init_conversion_context(&ctx);
38771     convert_VkPhysicalDeviceProperties2_win32_to_host(&ctx, params->pProperties, &pProperties_host);
38772     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pProperties_host);
38773     convert_VkPhysicalDeviceProperties2_host_to_win32(&pProperties_host, params->pProperties);
38774     free_conversion_context(&ctx);
38775     return STATUS_SUCCESS;
38776 }
38777
38778 #endif /* USE_STRUCT_CONVERSION */
38779
38780 #if !defined(USE_STRUCT_CONVERSION)
38781
38782 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(void *args)
38783 {
38784     struct vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_params *params = args;
38785
38786     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPerformanceQueryCreateInfo, params->pNumPasses);
38787
38788     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pPerformanceQueryCreateInfo, params->pNumPasses);
38789     return STATUS_SUCCESS;
38790 }
38791
38792 #else /* USE_STRUCT_CONVERSION */
38793
38794 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(void *args)
38795 {
38796     struct
38797     {
38798         VkPhysicalDevice physicalDevice;
38799         const VkQueryPoolPerformanceCreateInfoKHR32 *pPerformanceQueryCreateInfo;
38800         uint32_t *pNumPasses;
38801     } *params = args;
38802     VkQueryPoolPerformanceCreateInfoKHR pPerformanceQueryCreateInfo_host;
38803
38804     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPerformanceQueryCreateInfo, params->pNumPasses);
38805
38806     convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host(params->pPerformanceQueryCreateInfo, &pPerformanceQueryCreateInfo_host);
38807     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pPerformanceQueryCreateInfo_host, params->pNumPasses);
38808     return STATUS_SUCCESS;
38809 }
38810
38811 #endif /* USE_STRUCT_CONVERSION */
38812
38813 #if !defined(USE_STRUCT_CONVERSION)
38814
38815 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyProperties(void *args)
38816 {
38817     struct vkGetPhysicalDeviceQueueFamilyProperties_params *params = args;
38818
38819     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38820
38821     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38822     return STATUS_SUCCESS;
38823 }
38824
38825 #else /* USE_STRUCT_CONVERSION */
38826
38827 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties(void *args)
38828 {
38829     struct
38830     {
38831         VkPhysicalDevice physicalDevice;
38832         uint32_t *pQueueFamilyPropertyCount;
38833         VkQueueFamilyProperties *pQueueFamilyProperties;
38834     } *params = args;
38835
38836     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38837
38838     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38839     return STATUS_SUCCESS;
38840 }
38841
38842 #endif /* USE_STRUCT_CONVERSION */
38843
38844 #if !defined(USE_STRUCT_CONVERSION)
38845
38846 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyProperties2(void *args)
38847 {
38848     struct vkGetPhysicalDeviceQueueFamilyProperties2_params *params = args;
38849
38850     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38851
38852     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38853     return STATUS_SUCCESS;
38854 }
38855
38856 #else /* USE_STRUCT_CONVERSION */
38857
38858 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties2(void *args)
38859 {
38860     struct
38861     {
38862         VkPhysicalDevice physicalDevice;
38863         uint32_t *pQueueFamilyPropertyCount;
38864         VkQueueFamilyProperties232 *pQueueFamilyProperties;
38865     } *params = args;
38866     VkQueueFamilyProperties2 *pQueueFamilyProperties_host;
38867     struct conversion_context ctx;
38868
38869     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38870
38871     init_conversion_context(&ctx);
38872     pQueueFamilyProperties_host = convert_VkQueueFamilyProperties2_array_win32_to_host(&ctx, params->pQueueFamilyProperties, *params->pQueueFamilyPropertyCount);
38873     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, pQueueFamilyProperties_host);
38874     convert_VkQueueFamilyProperties2_array_host_to_win32(pQueueFamilyProperties_host, params->pQueueFamilyProperties, *params->pQueueFamilyPropertyCount);
38875     free_conversion_context(&ctx);
38876     return STATUS_SUCCESS;
38877 }
38878
38879 #endif /* USE_STRUCT_CONVERSION */
38880
38881 #if !defined(USE_STRUCT_CONVERSION)
38882
38883 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyProperties2KHR(void *args)
38884 {
38885     struct vkGetPhysicalDeviceQueueFamilyProperties2KHR_params *params = args;
38886
38887     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38888
38889     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38890     return STATUS_SUCCESS;
38891 }
38892
38893 #else /* USE_STRUCT_CONVERSION */
38894
38895 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties2KHR(void *args)
38896 {
38897     struct
38898     {
38899         VkPhysicalDevice physicalDevice;
38900         uint32_t *pQueueFamilyPropertyCount;
38901         VkQueueFamilyProperties232 *pQueueFamilyProperties;
38902     } *params = args;
38903     VkQueueFamilyProperties2 *pQueueFamilyProperties_host;
38904     struct conversion_context ctx;
38905
38906     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38907
38908     init_conversion_context(&ctx);
38909     pQueueFamilyProperties_host = convert_VkQueueFamilyProperties2_array_win32_to_host(&ctx, params->pQueueFamilyProperties, *params->pQueueFamilyPropertyCount);
38910     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, pQueueFamilyProperties_host);
38911     convert_VkQueueFamilyProperties2_array_host_to_win32(pQueueFamilyProperties_host, params->pQueueFamilyProperties, *params->pQueueFamilyPropertyCount);
38912     free_conversion_context(&ctx);
38913     return STATUS_SUCCESS;
38914 }
38915
38916 #endif /* USE_STRUCT_CONVERSION */
38917
38918 #if !defined(USE_STRUCT_CONVERSION)
38919
38920 static NTSTATUS thunk64_vkGetPhysicalDeviceSparseImageFormatProperties(void *args)
38921 {
38922     struct vkGetPhysicalDeviceSparseImageFormatProperties_params *params = args;
38923
38924     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p, %p\n", params->physicalDevice, params->format, params->type, params->samples, params->usage, params->tiling, params->pPropertyCount, params->pProperties);
38925
38926     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->type, params->samples, params->usage, params->tiling, params->pPropertyCount, params->pProperties);
38927     return STATUS_SUCCESS;
38928 }
38929
38930 #else /* USE_STRUCT_CONVERSION */
38931
38932 static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties(void *args)
38933 {
38934     struct
38935     {
38936         VkPhysicalDevice physicalDevice;
38937         VkFormat format;
38938         VkImageType type;
38939         VkSampleCountFlagBits samples;
38940         VkImageUsageFlags usage;
38941         VkImageTiling tiling;
38942         uint32_t *pPropertyCount;
38943         VkSparseImageFormatProperties *pProperties;
38944     } *params = args;
38945
38946     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p, %p\n", params->physicalDevice, params->format, params->type, params->samples, params->usage, params->tiling, params->pPropertyCount, params->pProperties);
38947
38948     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->type, params->samples, params->usage, params->tiling, params->pPropertyCount, params->pProperties);
38949     return STATUS_SUCCESS;
38950 }
38951
38952 #endif /* USE_STRUCT_CONVERSION */
38953
38954 #if !defined(USE_STRUCT_CONVERSION)
38955
38956 static NTSTATUS thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2(void *args)
38957 {
38958     struct vkGetPhysicalDeviceSparseImageFormatProperties2_params *params = args;
38959
38960     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
38961
38962     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFormatInfo, params->pPropertyCount, params->pProperties);
38963     return STATUS_SUCCESS;
38964 }
38965
38966 #else /* USE_STRUCT_CONVERSION */
38967
38968 static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2(void *args)
38969 {
38970     struct
38971     {
38972         VkPhysicalDevice physicalDevice;
38973         const VkPhysicalDeviceSparseImageFormatInfo232 *pFormatInfo;
38974         uint32_t *pPropertyCount;
38975         VkSparseImageFormatProperties232 *pProperties;
38976     } *params = args;
38977     VkPhysicalDeviceSparseImageFormatInfo2 pFormatInfo_host;
38978     VkSparseImageFormatProperties2 *pProperties_host;
38979     struct conversion_context ctx;
38980
38981     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
38982
38983     init_conversion_context(&ctx);
38984     convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(params->pFormatInfo, &pFormatInfo_host);
38985     pProperties_host = convert_VkSparseImageFormatProperties2_array_win32_to_host(&ctx, params->pProperties, *params->pPropertyCount);
38986     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pFormatInfo_host, params->pPropertyCount, pProperties_host);
38987     convert_VkSparseImageFormatProperties2_array_host_to_win32(pProperties_host, params->pProperties, *params->pPropertyCount);
38988     free_conversion_context(&ctx);
38989     return STATUS_SUCCESS;
38990 }
38991
38992 #endif /* USE_STRUCT_CONVERSION */
38993
38994 #if !defined(USE_STRUCT_CONVERSION)
38995
38996 static NTSTATUS thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(void *args)
38997 {
38998     struct vkGetPhysicalDeviceSparseImageFormatProperties2KHR_params *params = args;
38999
39000     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
39001
39002     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFormatInfo, params->pPropertyCount, params->pProperties);
39003     return STATUS_SUCCESS;
39004 }
39005
39006 #else /* USE_STRUCT_CONVERSION */
39007
39008 static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(void *args)
39009 {
39010     struct
39011     {
39012         VkPhysicalDevice physicalDevice;
39013         const VkPhysicalDeviceSparseImageFormatInfo232 *pFormatInfo;
39014         uint32_t *pPropertyCount;
39015         VkSparseImageFormatProperties232 *pProperties;
39016     } *params = args;
39017     VkPhysicalDeviceSparseImageFormatInfo2 pFormatInfo_host;
39018     VkSparseImageFormatProperties2 *pProperties_host;
39019     struct conversion_context ctx;
39020
39021     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
39022
39023     init_conversion_context(&ctx);
39024     convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(params->pFormatInfo, &pFormatInfo_host);
39025     pProperties_host = convert_VkSparseImageFormatProperties2_array_win32_to_host(&ctx, params->pProperties, *params->pPropertyCount);
39026     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pFormatInfo_host, params->pPropertyCount, pProperties_host);
39027     convert_VkSparseImageFormatProperties2_array_host_to_win32(pProperties_host, params->pProperties, *params->pPropertyCount);
39028     free_conversion_context(&ctx);
39029     return STATUS_SUCCESS;
39030 }
39031
39032 #endif /* USE_STRUCT_CONVERSION */
39033
39034 #if !defined(USE_STRUCT_CONVERSION)
39035
39036 static NTSTATUS thunk64_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(void *args)
39037 {
39038     struct vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_params *params = args;
39039
39040     TRACE("%p, %p, %p\n", params->physicalDevice, params->pCombinationCount, params->pCombinations);
39041
39042     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pCombinationCount, params->pCombinations);
39043     return STATUS_SUCCESS;
39044 }
39045
39046 #else /* USE_STRUCT_CONVERSION */
39047
39048 static NTSTATUS thunk32_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(void *args)
39049 {
39050     struct
39051     {
39052         VkPhysicalDevice physicalDevice;
39053         uint32_t *pCombinationCount;
39054         VkFramebufferMixedSamplesCombinationNV32 *pCombinations;
39055         VkResult result;
39056     } *params = args;
39057     VkFramebufferMixedSamplesCombinationNV *pCombinations_host;
39058     struct conversion_context ctx;
39059
39060     TRACE("%p, %p, %p\n", params->physicalDevice, params->pCombinationCount, params->pCombinations);
39061
39062     init_conversion_context(&ctx);
39063     pCombinations_host = convert_VkFramebufferMixedSamplesCombinationNV_array_win32_to_host(&ctx, params->pCombinations, *params->pCombinationCount);
39064     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pCombinationCount, pCombinations_host);
39065     convert_VkFramebufferMixedSamplesCombinationNV_array_host_to_win32(pCombinations_host, params->pCombinations, *params->pCombinationCount);
39066     free_conversion_context(&ctx);
39067     return STATUS_SUCCESS;
39068 }
39069
39070 #endif /* USE_STRUCT_CONVERSION */
39071
39072 #if !defined(USE_STRUCT_CONVERSION)
39073
39074 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceCapabilities2KHR(void *args)
39075 {
39076     struct vkGetPhysicalDeviceSurfaceCapabilities2KHR_params *params = args;
39077
39078     TRACE("%p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
39079
39080     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
39081     return STATUS_SUCCESS;
39082 }
39083
39084 #else /* USE_STRUCT_CONVERSION */
39085
39086 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceCapabilities2KHR(void *args)
39087 {
39088     struct
39089     {
39090         VkPhysicalDevice physicalDevice;
39091         const VkPhysicalDeviceSurfaceInfo2KHR32 *pSurfaceInfo;
39092         VkSurfaceCapabilities2KHR32 *pSurfaceCapabilities;
39093         VkResult result;
39094     } *params = args;
39095     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
39096     VkSurfaceCapabilities2KHR pSurfaceCapabilities_host;
39097     struct conversion_context ctx;
39098
39099     TRACE("%p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
39100
39101     init_conversion_context(&ctx);
39102     convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_host(params->pSurfaceInfo, &pSurfaceInfo_host);
39103     convert_VkSurfaceCapabilities2KHR_win32_to_host(&ctx, params->pSurfaceCapabilities, &pSurfaceCapabilities_host);
39104     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(params->physicalDevice, &pSurfaceInfo_host, &pSurfaceCapabilities_host);
39105     convert_VkSurfaceCapabilities2KHR_host_to_win32(&pSurfaceCapabilities_host, params->pSurfaceCapabilities);
39106     free_conversion_context(&ctx);
39107     return STATUS_SUCCESS;
39108 }
39109
39110 #endif /* USE_STRUCT_CONVERSION */
39111
39112 #if !defined(USE_STRUCT_CONVERSION)
39113
39114 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(void *args)
39115 {
39116     struct vkGetPhysicalDeviceSurfaceCapabilitiesKHR_params *params = args;
39117
39118     TRACE("%p, 0x%s, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceCapabilities);
39119
39120     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(params->physicalDevice, params->surface, params->pSurfaceCapabilities);
39121     return STATUS_SUCCESS;
39122 }
39123
39124 #else /* USE_STRUCT_CONVERSION */
39125
39126 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(void *args)
39127 {
39128     struct
39129     {
39130         VkPhysicalDevice physicalDevice;
39131         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
39132         VkSurfaceCapabilitiesKHR *pSurfaceCapabilities;
39133         VkResult result;
39134     } *params = args;
39135
39136     TRACE("%p, 0x%s, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceCapabilities);
39137
39138     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(params->physicalDevice, params->surface, params->pSurfaceCapabilities);
39139     return STATUS_SUCCESS;
39140 }
39141
39142 #endif /* USE_STRUCT_CONVERSION */
39143
39144 #if !defined(USE_STRUCT_CONVERSION)
39145
39146 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceFormats2KHR(void *args)
39147 {
39148     struct vkGetPhysicalDeviceSurfaceFormats2KHR_params *params = args;
39149     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
39150
39151     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceFormatCount, params->pSurfaceFormats);
39152
39153     convert_VkPhysicalDeviceSurfaceInfo2KHR_win64_to_host(params->pSurfaceInfo, &pSurfaceInfo_host);
39154     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormats2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pSurfaceInfo_host, params->pSurfaceFormatCount, params->pSurfaceFormats);
39155     return STATUS_SUCCESS;
39156 }
39157
39158 #else /* USE_STRUCT_CONVERSION */
39159
39160 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceFormats2KHR(void *args)
39161 {
39162     struct
39163     {
39164         VkPhysicalDevice physicalDevice;
39165         const VkPhysicalDeviceSurfaceInfo2KHR32 *pSurfaceInfo;
39166         uint32_t *pSurfaceFormatCount;
39167         VkSurfaceFormat2KHR32 *pSurfaceFormats;
39168         VkResult result;
39169     } *params = args;
39170     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
39171     VkSurfaceFormat2KHR *pSurfaceFormats_host;
39172     struct conversion_context ctx;
39173
39174     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceFormatCount, params->pSurfaceFormats);
39175
39176     init_conversion_context(&ctx);
39177     convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_host(params->pSurfaceInfo, &pSurfaceInfo_host);
39178     pSurfaceFormats_host = convert_VkSurfaceFormat2KHR_array_win32_to_host(&ctx, params->pSurfaceFormats, *params->pSurfaceFormatCount);
39179     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormats2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pSurfaceInfo_host, params->pSurfaceFormatCount, pSurfaceFormats_host);
39180     convert_VkSurfaceFormat2KHR_array_host_to_win32(pSurfaceFormats_host, params->pSurfaceFormats, *params->pSurfaceFormatCount);
39181     free_conversion_context(&ctx);
39182     return STATUS_SUCCESS;
39183 }
39184
39185 #endif /* USE_STRUCT_CONVERSION */
39186
39187 #if !defined(USE_STRUCT_CONVERSION)
39188
39189 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceFormatsKHR(void *args)
39190 {
39191     struct vkGetPhysicalDeviceSurfaceFormatsKHR_params *params = args;
39192
39193     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceFormatCount, params->pSurfaceFormats);
39194
39195     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormatsKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pSurfaceFormatCount, params->pSurfaceFormats);
39196     return STATUS_SUCCESS;
39197 }
39198
39199 #else /* USE_STRUCT_CONVERSION */
39200
39201 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceFormatsKHR(void *args)
39202 {
39203     struct
39204     {
39205         VkPhysicalDevice physicalDevice;
39206         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
39207         uint32_t *pSurfaceFormatCount;
39208         VkSurfaceFormatKHR *pSurfaceFormats;
39209         VkResult result;
39210     } *params = args;
39211
39212     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceFormatCount, params->pSurfaceFormats);
39213
39214     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormatsKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pSurfaceFormatCount, params->pSurfaceFormats);
39215     return STATUS_SUCCESS;
39216 }
39217
39218 #endif /* USE_STRUCT_CONVERSION */
39219
39220 #if !defined(USE_STRUCT_CONVERSION)
39221
39222 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfacePresentModesKHR(void *args)
39223 {
39224     struct vkGetPhysicalDeviceSurfacePresentModesKHR_params *params = args;
39225
39226     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pPresentModeCount, params->pPresentModes);
39227
39228     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfacePresentModesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pPresentModeCount, params->pPresentModes);
39229     return STATUS_SUCCESS;
39230 }
39231
39232 #else /* USE_STRUCT_CONVERSION */
39233
39234 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfacePresentModesKHR(void *args)
39235 {
39236     struct
39237     {
39238         VkPhysicalDevice physicalDevice;
39239         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
39240         uint32_t *pPresentModeCount;
39241         VkPresentModeKHR *pPresentModes;
39242         VkResult result;
39243     } *params = args;
39244
39245     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pPresentModeCount, params->pPresentModes);
39246
39247     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfacePresentModesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pPresentModeCount, params->pPresentModes);
39248     return STATUS_SUCCESS;
39249 }
39250
39251 #endif /* USE_STRUCT_CONVERSION */
39252
39253 #if !defined(USE_STRUCT_CONVERSION)
39254
39255 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceSupportKHR(void *args)
39256 {
39257     struct vkGetPhysicalDeviceSurfaceSupportKHR_params *params = args;
39258
39259     TRACE("%p, %u, 0x%s, %p\n", params->physicalDevice, params->queueFamilyIndex, wine_dbgstr_longlong(params->surface), params->pSupported);
39260
39261     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex, wine_surface_from_handle(params->surface)->driver_surface, params->pSupported);
39262     return STATUS_SUCCESS;
39263 }
39264
39265 #else /* USE_STRUCT_CONVERSION */
39266
39267 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceSupportKHR(void *args)
39268 {
39269     struct
39270     {
39271         VkPhysicalDevice physicalDevice;
39272         uint32_t queueFamilyIndex;
39273         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
39274         VkBool32 *pSupported;
39275         VkResult result;
39276     } *params = args;
39277
39278     TRACE("%p, %u, 0x%s, %p\n", params->physicalDevice, params->queueFamilyIndex, wine_dbgstr_longlong(params->surface), params->pSupported);
39279
39280     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex, wine_surface_from_handle(params->surface)->driver_surface, params->pSupported);
39281     return STATUS_SUCCESS;
39282 }
39283
39284 #endif /* USE_STRUCT_CONVERSION */
39285
39286 #if !defined(USE_STRUCT_CONVERSION)
39287
39288 static NTSTATUS thunk64_vkGetPhysicalDeviceToolProperties(void *args)
39289 {
39290     struct vkGetPhysicalDeviceToolProperties_params *params = args;
39291
39292     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
39293
39294     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceToolProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pToolCount, params->pToolProperties);
39295     return STATUS_SUCCESS;
39296 }
39297
39298 #else /* USE_STRUCT_CONVERSION */
39299
39300 static NTSTATUS thunk32_vkGetPhysicalDeviceToolProperties(void *args)
39301 {
39302     struct
39303     {
39304         VkPhysicalDevice physicalDevice;
39305         uint32_t *pToolCount;
39306         VkPhysicalDeviceToolProperties32 *pToolProperties;
39307         VkResult result;
39308     } *params = args;
39309     VkPhysicalDeviceToolProperties *pToolProperties_host;
39310     struct conversion_context ctx;
39311
39312     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
39313
39314     init_conversion_context(&ctx);
39315     pToolProperties_host = convert_VkPhysicalDeviceToolProperties_array_win32_to_host(&ctx, params->pToolProperties, *params->pToolCount);
39316     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceToolProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pToolCount, pToolProperties_host);
39317     convert_VkPhysicalDeviceToolProperties_array_host_to_win32(pToolProperties_host, params->pToolProperties, *params->pToolCount);
39318     free_conversion_context(&ctx);
39319     return STATUS_SUCCESS;
39320 }
39321
39322 #endif /* USE_STRUCT_CONVERSION */
39323
39324 #if !defined(USE_STRUCT_CONVERSION)
39325
39326 static NTSTATUS thunk64_vkGetPhysicalDeviceToolPropertiesEXT(void *args)
39327 {
39328     struct vkGetPhysicalDeviceToolPropertiesEXT_params *params = args;
39329
39330     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
39331
39332     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceToolPropertiesEXT(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pToolCount, params->pToolProperties);
39333     return STATUS_SUCCESS;
39334 }
39335
39336 #else /* USE_STRUCT_CONVERSION */
39337
39338 static NTSTATUS thunk32_vkGetPhysicalDeviceToolPropertiesEXT(void *args)
39339 {
39340     struct
39341     {
39342         VkPhysicalDevice physicalDevice;
39343         uint32_t *pToolCount;
39344         VkPhysicalDeviceToolProperties32 *pToolProperties;
39345         VkResult result;
39346     } *params = args;
39347     VkPhysicalDeviceToolProperties *pToolProperties_host;
39348     struct conversion_context ctx;
39349
39350     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
39351
39352     init_conversion_context(&ctx);
39353     pToolProperties_host = convert_VkPhysicalDeviceToolProperties_array_win32_to_host(&ctx, params->pToolProperties, *params->pToolCount);
39354     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceToolPropertiesEXT(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pToolCount, pToolProperties_host);
39355     convert_VkPhysicalDeviceToolProperties_array_host_to_win32(pToolProperties_host, params->pToolProperties, *params->pToolCount);
39356     free_conversion_context(&ctx);
39357     return STATUS_SUCCESS;
39358 }
39359
39360 #endif /* USE_STRUCT_CONVERSION */
39361
39362 #if !defined(USE_STRUCT_CONVERSION)
39363
39364 static NTSTATUS thunk64_vkGetPhysicalDeviceWin32PresentationSupportKHR(void *args)
39365 {
39366     struct vkGetPhysicalDeviceWin32PresentationSupportKHR_params *params = args;
39367
39368     TRACE("%p, %u\n", params->physicalDevice, params->queueFamilyIndex);
39369
39370     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex);
39371     return STATUS_SUCCESS;
39372 }
39373
39374 #else /* USE_STRUCT_CONVERSION */
39375
39376 static NTSTATUS thunk32_vkGetPhysicalDeviceWin32PresentationSupportKHR(void *args)
39377 {
39378     struct
39379     {
39380         VkPhysicalDevice physicalDevice;
39381         uint32_t queueFamilyIndex;
39382         VkBool32 result;
39383     } *params = args;
39384
39385     TRACE("%p, %u\n", params->physicalDevice, params->queueFamilyIndex);
39386
39387     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex);
39388     return STATUS_SUCCESS;
39389 }
39390
39391 #endif /* USE_STRUCT_CONVERSION */
39392
39393 #if !defined(USE_STRUCT_CONVERSION)
39394
39395 static NTSTATUS thunk64_vkGetPipelineCacheData(void *args)
39396 {
39397     struct vkGetPipelineCacheData_params *params = args;
39398
39399     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pDataSize, params->pData);
39400
39401     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineCacheData(wine_device_from_handle(params->device)->device, params->pipelineCache, params->pDataSize, params->pData);
39402     return STATUS_SUCCESS;
39403 }
39404
39405 #else /* USE_STRUCT_CONVERSION */
39406
39407 static NTSTATUS thunk32_vkGetPipelineCacheData(void *args)
39408 {
39409     struct
39410     {
39411         VkDevice device;
39412         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
39413         size_t *pDataSize;
39414         void *pData;
39415         VkResult result;
39416     } *params = args;
39417
39418     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pDataSize, params->pData);
39419
39420     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineCacheData(wine_device_from_handle(params->device)->device, params->pipelineCache, params->pDataSize, params->pData);
39421     return STATUS_SUCCESS;
39422 }
39423
39424 #endif /* USE_STRUCT_CONVERSION */
39425
39426 #if !defined(USE_STRUCT_CONVERSION)
39427
39428 static NTSTATUS thunk64_vkGetPipelineExecutableInternalRepresentationsKHR(void *args)
39429 {
39430     struct vkGetPipelineExecutableInternalRepresentationsKHR_params *params = args;
39431
39432     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
39433
39434     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableInternalRepresentationsKHR(wine_device_from_handle(params->device)->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
39435     return STATUS_SUCCESS;
39436 }
39437
39438 #else /* USE_STRUCT_CONVERSION */
39439
39440 static NTSTATUS thunk32_vkGetPipelineExecutableInternalRepresentationsKHR(void *args)
39441 {
39442     struct
39443     {
39444         VkDevice device;
39445         const VkPipelineExecutableInfoKHR32 *pExecutableInfo;
39446         uint32_t *pInternalRepresentationCount;
39447         VkPipelineExecutableInternalRepresentationKHR32 *pInternalRepresentations;
39448         VkResult result;
39449     } *params = args;
39450     VkPipelineExecutableInfoKHR pExecutableInfo_host;
39451     VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations_host;
39452     struct conversion_context ctx;
39453
39454     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
39455
39456     init_conversion_context(&ctx);
39457     convert_VkPipelineExecutableInfoKHR_win32_to_host(params->pExecutableInfo, &pExecutableInfo_host);
39458     pInternalRepresentations_host = convert_VkPipelineExecutableInternalRepresentationKHR_array_win32_to_host(&ctx, params->pInternalRepresentations, *params->pInternalRepresentationCount);
39459     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableInternalRepresentationsKHR(wine_device_from_handle(params->device)->device, &pExecutableInfo_host, params->pInternalRepresentationCount, pInternalRepresentations_host);
39460     convert_VkPipelineExecutableInternalRepresentationKHR_array_host_to_win32(pInternalRepresentations_host, params->pInternalRepresentations, *params->pInternalRepresentationCount);
39461     free_conversion_context(&ctx);
39462     return STATUS_SUCCESS;
39463 }
39464
39465 #endif /* USE_STRUCT_CONVERSION */
39466
39467 #if !defined(USE_STRUCT_CONVERSION)
39468
39469 static NTSTATUS thunk64_vkGetPipelineExecutablePropertiesKHR(void *args)
39470 {
39471     struct vkGetPipelineExecutablePropertiesKHR_params *params = args;
39472
39473     TRACE("%p, %p, %p, %p\n", params->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
39474
39475     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutablePropertiesKHR(wine_device_from_handle(params->device)->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
39476     return STATUS_SUCCESS;
39477 }
39478
39479 #else /* USE_STRUCT_CONVERSION */
39480
39481 static NTSTATUS thunk32_vkGetPipelineExecutablePropertiesKHR(void *args)
39482 {
39483     struct
39484     {
39485         VkDevice device;
39486         const VkPipelineInfoKHR32 *pPipelineInfo;
39487         uint32_t *pExecutableCount;
39488         VkPipelineExecutablePropertiesKHR32 *pProperties;
39489         VkResult result;
39490     } *params = args;
39491     VkPipelineInfoKHR pPipelineInfo_host;
39492     VkPipelineExecutablePropertiesKHR *pProperties_host;
39493     struct conversion_context ctx;
39494
39495     TRACE("%p, %p, %p, %p\n", params->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
39496
39497     init_conversion_context(&ctx);
39498     convert_VkPipelineInfoKHR_win32_to_host(params->pPipelineInfo, &pPipelineInfo_host);
39499     pProperties_host = convert_VkPipelineExecutablePropertiesKHR_array_win32_to_host(&ctx, params->pProperties, *params->pExecutableCount);
39500     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutablePropertiesKHR(wine_device_from_handle(params->device)->device, &pPipelineInfo_host, params->pExecutableCount, pProperties_host);
39501     convert_VkPipelineExecutablePropertiesKHR_array_host_to_win32(pProperties_host, params->pProperties, *params->pExecutableCount);
39502     free_conversion_context(&ctx);
39503     return STATUS_SUCCESS;
39504 }
39505
39506 #endif /* USE_STRUCT_CONVERSION */
39507
39508 #if !defined(USE_STRUCT_CONVERSION)
39509
39510 static NTSTATUS thunk64_vkGetPipelineExecutableStatisticsKHR(void *args)
39511 {
39512     struct vkGetPipelineExecutableStatisticsKHR_params *params = args;
39513
39514     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
39515
39516     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableStatisticsKHR(wine_device_from_handle(params->device)->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
39517     return STATUS_SUCCESS;
39518 }
39519
39520 #else /* USE_STRUCT_CONVERSION */
39521
39522 static NTSTATUS thunk32_vkGetPipelineExecutableStatisticsKHR(void *args)
39523 {
39524     struct
39525     {
39526         VkDevice device;
39527         const VkPipelineExecutableInfoKHR32 *pExecutableInfo;
39528         uint32_t *pStatisticCount;
39529         VkPipelineExecutableStatisticKHR32 *pStatistics;
39530         VkResult result;
39531     } *params = args;
39532     VkPipelineExecutableInfoKHR pExecutableInfo_host;
39533     VkPipelineExecutableStatisticKHR *pStatistics_host;
39534     struct conversion_context ctx;
39535
39536     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
39537
39538     init_conversion_context(&ctx);
39539     convert_VkPipelineExecutableInfoKHR_win32_to_host(params->pExecutableInfo, &pExecutableInfo_host);
39540     pStatistics_host = convert_VkPipelineExecutableStatisticKHR_array_win32_to_host(&ctx, params->pStatistics, *params->pStatisticCount);
39541     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableStatisticsKHR(wine_device_from_handle(params->device)->device, &pExecutableInfo_host, params->pStatisticCount, pStatistics_host);
39542     convert_VkPipelineExecutableStatisticKHR_array_host_to_win32(pStatistics_host, params->pStatistics, *params->pStatisticCount);
39543     free_conversion_context(&ctx);
39544     return STATUS_SUCCESS;
39545 }
39546
39547 #endif /* USE_STRUCT_CONVERSION */
39548
39549 #if !defined(USE_STRUCT_CONVERSION)
39550
39551 static NTSTATUS thunk64_vkGetPipelinePropertiesEXT(void *args)
39552 {
39553     struct vkGetPipelinePropertiesEXT_params *params = args;
39554
39555     TRACE("%p, %p, %p\n", params->device, params->pPipelineInfo, params->pPipelineProperties);
39556
39557     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelinePropertiesEXT(wine_device_from_handle(params->device)->device, params->pPipelineInfo, params->pPipelineProperties);
39558     return STATUS_SUCCESS;
39559 }
39560
39561 #else /* USE_STRUCT_CONVERSION */
39562
39563 static NTSTATUS thunk32_vkGetPipelinePropertiesEXT(void *args)
39564 {
39565     struct
39566     {
39567         VkDevice device;
39568         const VkPipelineInfoEXT32 *pPipelineInfo;
39569         VkBaseOutStructure *pPipelineProperties;
39570         VkResult result;
39571     } *params = args;
39572     VkPipelineInfoEXT pPipelineInfo_host;
39573
39574     TRACE("%p, %p, %p\n", params->device, params->pPipelineInfo, params->pPipelineProperties);
39575
39576     convert_VkPipelineInfoEXT_win32_to_host(params->pPipelineInfo, &pPipelineInfo_host);
39577     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelinePropertiesEXT(wine_device_from_handle(params->device)->device, &pPipelineInfo_host, params->pPipelineProperties);
39578     return STATUS_SUCCESS;
39579 }
39580
39581 #endif /* USE_STRUCT_CONVERSION */
39582
39583 #if !defined(USE_STRUCT_CONVERSION)
39584
39585 static NTSTATUS thunk64_vkGetPrivateData(void *args)
39586 {
39587     struct vkGetPrivateData_params *params = args;
39588
39589     TRACE("%p, %#x, 0x%s, 0x%s, %p\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), params->pData);
39590
39591     wine_device_from_handle(params->device)->funcs.p_vkGetPrivateData(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->pData);
39592     return STATUS_SUCCESS;
39593 }
39594
39595 #else /* USE_STRUCT_CONVERSION */
39596
39597 static NTSTATUS thunk32_vkGetPrivateData(void *args)
39598 {
39599     struct
39600     {
39601         VkDevice device;
39602         VkObjectType objectType;
39603         uint64_t DECLSPEC_ALIGN(8) objectHandle;
39604         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
39605         uint64_t *pData;
39606     } *params = args;
39607
39608     TRACE("%p, %#x, 0x%s, 0x%s, %p\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), params->pData);
39609
39610     wine_device_from_handle(params->device)->funcs.p_vkGetPrivateData(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->pData);
39611     return STATUS_SUCCESS;
39612 }
39613
39614 #endif /* USE_STRUCT_CONVERSION */
39615
39616 #if !defined(USE_STRUCT_CONVERSION)
39617
39618 static NTSTATUS thunk64_vkGetPrivateDataEXT(void *args)
39619 {
39620     struct vkGetPrivateDataEXT_params *params = args;
39621
39622     TRACE("%p, %#x, 0x%s, 0x%s, %p\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), params->pData);
39623
39624     wine_device_from_handle(params->device)->funcs.p_vkGetPrivateDataEXT(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->pData);
39625     return STATUS_SUCCESS;
39626 }
39627
39628 #else /* USE_STRUCT_CONVERSION */
39629
39630 static NTSTATUS thunk32_vkGetPrivateDataEXT(void *args)
39631 {
39632     struct
39633     {
39634         VkDevice device;
39635         VkObjectType objectType;
39636         uint64_t DECLSPEC_ALIGN(8) objectHandle;
39637         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
39638         uint64_t *pData;
39639     } *params = args;
39640
39641     TRACE("%p, %#x, 0x%s, 0x%s, %p\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), params->pData);
39642
39643     wine_device_from_handle(params->device)->funcs.p_vkGetPrivateDataEXT(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->pData);
39644     return STATUS_SUCCESS;
39645 }
39646
39647 #endif /* USE_STRUCT_CONVERSION */
39648
39649 #if !defined(USE_STRUCT_CONVERSION)
39650
39651 static NTSTATUS thunk64_vkGetQueryPoolResults(void *args)
39652 {
39653     struct vkGetQueryPoolResults_params *params = args;
39654
39655     TRACE("%p, 0x%s, %u, %u, 0x%s, %p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride), params->flags);
39656
39657     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetQueryPoolResults(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount, params->dataSize, params->pData, params->stride, params->flags);
39658     return STATUS_SUCCESS;
39659 }
39660
39661 #else /* USE_STRUCT_CONVERSION */
39662
39663 static NTSTATUS thunk32_vkGetQueryPoolResults(void *args)
39664 {
39665     struct
39666     {
39667         VkDevice device;
39668         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
39669         uint32_t firstQuery;
39670         uint32_t queryCount;
39671         size_t dataSize;
39672         void *pData;
39673         VkDeviceSize DECLSPEC_ALIGN(8) stride;
39674         VkQueryResultFlags flags;
39675         VkResult result;
39676     } *params = args;
39677
39678     TRACE("%p, 0x%s, %u, %u, 0x%s, %p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride), params->flags);
39679
39680     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetQueryPoolResults(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount, params->dataSize, params->pData, params->stride, params->flags);
39681     return STATUS_SUCCESS;
39682 }
39683
39684 #endif /* USE_STRUCT_CONVERSION */
39685
39686 #if !defined(USE_STRUCT_CONVERSION)
39687
39688 static NTSTATUS thunk64_vkGetQueueCheckpointData2NV(void *args)
39689 {
39690     struct vkGetQueueCheckpointData2NV_params *params = args;
39691
39692     TRACE("%p, %p, %p\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
39693
39694     wine_queue_from_handle(params->queue)->device->funcs.p_vkGetQueueCheckpointData2NV(wine_queue_from_handle(params->queue)->queue, params->pCheckpointDataCount, params->pCheckpointData);
39695     return STATUS_SUCCESS;
39696 }
39697
39698 #else /* USE_STRUCT_CONVERSION */
39699
39700 static NTSTATUS thunk32_vkGetQueueCheckpointData2NV(void *args)
39701 {
39702     struct
39703     {
39704         VkQueue queue;
39705         uint32_t *pCheckpointDataCount;
39706         VkCheckpointData2NV32 *pCheckpointData;
39707     } *params = args;
39708     VkCheckpointData2NV *pCheckpointData_host;
39709     struct conversion_context ctx;
39710
39711     TRACE("%p, %p, %p\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
39712
39713     init_conversion_context(&ctx);
39714     pCheckpointData_host = convert_VkCheckpointData2NV_array_win32_to_host(&ctx, params->pCheckpointData, *params->pCheckpointDataCount);
39715     wine_queue_from_handle(params->queue)->device->funcs.p_vkGetQueueCheckpointData2NV(wine_queue_from_handle(params->queue)->queue, params->pCheckpointDataCount, pCheckpointData_host);
39716     convert_VkCheckpointData2NV_array_host_to_win32(pCheckpointData_host, params->pCheckpointData, *params->pCheckpointDataCount);
39717     free_conversion_context(&ctx);
39718     return STATUS_SUCCESS;
39719 }
39720
39721 #endif /* USE_STRUCT_CONVERSION */
39722
39723 #if !defined(USE_STRUCT_CONVERSION)
39724
39725 static NTSTATUS thunk64_vkGetQueueCheckpointDataNV(void *args)
39726 {
39727     struct vkGetQueueCheckpointDataNV_params *params = args;
39728
39729     TRACE("%p, %p, %p\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
39730
39731     wine_queue_from_handle(params->queue)->device->funcs.p_vkGetQueueCheckpointDataNV(wine_queue_from_handle(params->queue)->queue, params->pCheckpointDataCount, params->pCheckpointData);
39732     return STATUS_SUCCESS;
39733 }
39734
39735 #else /* USE_STRUCT_CONVERSION */
39736
39737 static NTSTATUS thunk32_vkGetQueueCheckpointDataNV(void *args)
39738 {
39739     struct
39740     {
39741         VkQueue queue;
39742         uint32_t *pCheckpointDataCount;
39743         VkCheckpointDataNV32 *pCheckpointData;
39744     } *params = args;
39745     VkCheckpointDataNV *pCheckpointData_host;
39746     struct conversion_context ctx;
39747
39748     TRACE("%p, %p, %p\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
39749
39750     init_conversion_context(&ctx);
39751     pCheckpointData_host = convert_VkCheckpointDataNV_array_win32_to_host(&ctx, params->pCheckpointData, *params->pCheckpointDataCount);
39752     wine_queue_from_handle(params->queue)->device->funcs.p_vkGetQueueCheckpointDataNV(wine_queue_from_handle(params->queue)->queue, params->pCheckpointDataCount, pCheckpointData_host);
39753     convert_VkCheckpointDataNV_array_host_to_win32(pCheckpointData_host, params->pCheckpointData, *params->pCheckpointDataCount);
39754     free_conversion_context(&ctx);
39755     return STATUS_SUCCESS;
39756 }
39757
39758 #endif /* USE_STRUCT_CONVERSION */
39759
39760 #if !defined(USE_STRUCT_CONVERSION)
39761
39762 static NTSTATUS thunk64_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(void *args)
39763 {
39764     struct vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_params *params = args;
39765
39766     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);
39767
39768     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
39769     return STATUS_SUCCESS;
39770 }
39771
39772 #else /* USE_STRUCT_CONVERSION */
39773
39774 static NTSTATUS thunk32_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(void *args)
39775 {
39776     struct
39777     {
39778         VkDevice device;
39779         VkPipeline DECLSPEC_ALIGN(8) pipeline;
39780         uint32_t firstGroup;
39781         uint32_t groupCount;
39782         size_t dataSize;
39783         void *pData;
39784         VkResult result;
39785     } *params = args;
39786
39787     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);
39788
39789     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
39790     return STATUS_SUCCESS;
39791 }
39792
39793 #endif /* USE_STRUCT_CONVERSION */
39794
39795 #if !defined(USE_STRUCT_CONVERSION)
39796
39797 static NTSTATUS thunk64_vkGetRayTracingShaderGroupHandlesKHR(void *args)
39798 {
39799     struct vkGetRayTracingShaderGroupHandlesKHR_params *params = args;
39800
39801     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);
39802
39803     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupHandlesKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
39804     return STATUS_SUCCESS;
39805 }
39806
39807 #else /* USE_STRUCT_CONVERSION */
39808
39809 static NTSTATUS thunk32_vkGetRayTracingShaderGroupHandlesKHR(void *args)
39810 {
39811     struct
39812     {
39813         VkDevice device;
39814         VkPipeline DECLSPEC_ALIGN(8) pipeline;
39815         uint32_t firstGroup;
39816         uint32_t groupCount;
39817         size_t dataSize;
39818         void *pData;
39819         VkResult result;
39820     } *params = args;
39821
39822     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);
39823
39824     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupHandlesKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
39825     return STATUS_SUCCESS;
39826 }
39827
39828 #endif /* USE_STRUCT_CONVERSION */
39829
39830 #if !defined(USE_STRUCT_CONVERSION)
39831
39832 static NTSTATUS thunk64_vkGetRayTracingShaderGroupHandlesNV(void *args)
39833 {
39834     struct vkGetRayTracingShaderGroupHandlesNV_params *params = args;
39835
39836     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);
39837
39838     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupHandlesNV(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
39839     return STATUS_SUCCESS;
39840 }
39841
39842 #else /* USE_STRUCT_CONVERSION */
39843
39844 static NTSTATUS thunk32_vkGetRayTracingShaderGroupHandlesNV(void *args)
39845 {
39846     struct
39847     {
39848         VkDevice device;
39849         VkPipeline DECLSPEC_ALIGN(8) pipeline;
39850         uint32_t firstGroup;
39851         uint32_t groupCount;
39852         size_t dataSize;
39853         void *pData;
39854         VkResult result;
39855     } *params = args;
39856
39857     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);
39858
39859     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupHandlesNV(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
39860     return STATUS_SUCCESS;
39861 }
39862
39863 #endif /* USE_STRUCT_CONVERSION */
39864
39865 #if !defined(USE_STRUCT_CONVERSION)
39866
39867 static NTSTATUS thunk64_vkGetRayTracingShaderGroupStackSizeKHR(void *args)
39868 {
39869     struct vkGetRayTracingShaderGroupStackSizeKHR_params *params = args;
39870
39871     TRACE("%p, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->group, params->groupShader);
39872
39873     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupStackSizeKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->group, params->groupShader);
39874     return STATUS_SUCCESS;
39875 }
39876
39877 #else /* USE_STRUCT_CONVERSION */
39878
39879 static NTSTATUS thunk32_vkGetRayTracingShaderGroupStackSizeKHR(void *args)
39880 {
39881     struct
39882     {
39883         VkDevice device;
39884         VkPipeline DECLSPEC_ALIGN(8) pipeline;
39885         uint32_t group;
39886         VkShaderGroupShaderKHR groupShader;
39887         VkDeviceSize result;
39888     } *params = args;
39889
39890     TRACE("%p, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->group, params->groupShader);
39891
39892     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupStackSizeKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->group, params->groupShader);
39893     return STATUS_SUCCESS;
39894 }
39895
39896 #endif /* USE_STRUCT_CONVERSION */
39897
39898 #if !defined(USE_STRUCT_CONVERSION)
39899
39900 static NTSTATUS thunk64_vkGetRenderAreaGranularity(void *args)
39901 {
39902     struct vkGetRenderAreaGranularity_params *params = args;
39903
39904     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pGranularity);
39905
39906     wine_device_from_handle(params->device)->funcs.p_vkGetRenderAreaGranularity(wine_device_from_handle(params->device)->device, params->renderPass, params->pGranularity);
39907     return STATUS_SUCCESS;
39908 }
39909
39910 #else /* USE_STRUCT_CONVERSION */
39911
39912 static NTSTATUS thunk32_vkGetRenderAreaGranularity(void *args)
39913 {
39914     struct
39915     {
39916         VkDevice device;
39917         VkRenderPass DECLSPEC_ALIGN(8) renderPass;
39918         VkExtent2D *pGranularity;
39919     } *params = args;
39920
39921     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pGranularity);
39922
39923     wine_device_from_handle(params->device)->funcs.p_vkGetRenderAreaGranularity(wine_device_from_handle(params->device)->device, params->renderPass, params->pGranularity);
39924     return STATUS_SUCCESS;
39925 }
39926
39927 #endif /* USE_STRUCT_CONVERSION */
39928
39929 #if !defined(USE_STRUCT_CONVERSION)
39930
39931 static NTSTATUS thunk64_vkGetSemaphoreCounterValue(void *args)
39932 {
39933     struct vkGetSemaphoreCounterValue_params *params = args;
39934
39935     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
39936
39937     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValue(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
39938     return STATUS_SUCCESS;
39939 }
39940
39941 #else /* USE_STRUCT_CONVERSION */
39942
39943 static NTSTATUS thunk32_vkGetSemaphoreCounterValue(void *args)
39944 {
39945     struct
39946     {
39947         VkDevice device;
39948         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
39949         uint64_t *pValue;
39950         VkResult result;
39951     } *params = args;
39952
39953     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
39954
39955     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValue(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
39956     return STATUS_SUCCESS;
39957 }
39958
39959 #endif /* USE_STRUCT_CONVERSION */
39960
39961 #if !defined(USE_STRUCT_CONVERSION)
39962
39963 static NTSTATUS thunk64_vkGetSemaphoreCounterValueKHR(void *args)
39964 {
39965     struct vkGetSemaphoreCounterValueKHR_params *params = args;
39966
39967     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
39968
39969     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValueKHR(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
39970     return STATUS_SUCCESS;
39971 }
39972
39973 #else /* USE_STRUCT_CONVERSION */
39974
39975 static NTSTATUS thunk32_vkGetSemaphoreCounterValueKHR(void *args)
39976 {
39977     struct
39978     {
39979         VkDevice device;
39980         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
39981         uint64_t *pValue;
39982         VkResult result;
39983     } *params = args;
39984
39985     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
39986
39987     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValueKHR(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
39988     return STATUS_SUCCESS;
39989 }
39990
39991 #endif /* USE_STRUCT_CONVERSION */
39992
39993 #if !defined(USE_STRUCT_CONVERSION)
39994
39995 static NTSTATUS thunk64_vkGetShaderInfoAMD(void *args)
39996 {
39997     struct vkGetShaderInfoAMD_params *params = args;
39998
39999     TRACE("%p, 0x%s, %#x, %#x, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);
40000
40001     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetShaderInfoAMD(wine_device_from_handle(params->device)->device, params->pipeline, params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);
40002     return STATUS_SUCCESS;
40003 }
40004
40005 #else /* USE_STRUCT_CONVERSION */
40006
40007 static NTSTATUS thunk32_vkGetShaderInfoAMD(void *args)
40008 {
40009     struct
40010     {
40011         VkDevice device;
40012         VkPipeline DECLSPEC_ALIGN(8) pipeline;
40013         VkShaderStageFlagBits shaderStage;
40014         VkShaderInfoTypeAMD infoType;
40015         size_t *pInfoSize;
40016         void *pInfo;
40017         VkResult result;
40018     } *params = args;
40019
40020     TRACE("%p, 0x%s, %#x, %#x, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);
40021
40022     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetShaderInfoAMD(wine_device_from_handle(params->device)->device, params->pipeline, params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);
40023     return STATUS_SUCCESS;
40024 }
40025
40026 #endif /* USE_STRUCT_CONVERSION */
40027
40028 #if !defined(USE_STRUCT_CONVERSION)
40029
40030 static NTSTATUS thunk64_vkGetShaderModuleCreateInfoIdentifierEXT(void *args)
40031 {
40032     struct vkGetShaderModuleCreateInfoIdentifierEXT_params *params = args;
40033
40034     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pIdentifier);
40035
40036     wine_device_from_handle(params->device)->funcs.p_vkGetShaderModuleCreateInfoIdentifierEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pIdentifier);
40037     return STATUS_SUCCESS;
40038 }
40039
40040 #else /* USE_STRUCT_CONVERSION */
40041
40042 static NTSTATUS thunk32_vkGetShaderModuleCreateInfoIdentifierEXT(void *args)
40043 {
40044     struct
40045     {
40046         VkDevice device;
40047         const VkShaderModuleCreateInfo32 *pCreateInfo;
40048         VkShaderModuleIdentifierEXT32 *pIdentifier;
40049     } *params = args;
40050     VkShaderModuleCreateInfo pCreateInfo_host;
40051     VkShaderModuleIdentifierEXT pIdentifier_host;
40052     struct conversion_context ctx;
40053
40054     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pIdentifier);
40055
40056     init_conversion_context(&ctx);
40057     convert_VkShaderModuleCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
40058     convert_VkShaderModuleIdentifierEXT_win32_to_host(params->pIdentifier, &pIdentifier_host);
40059     wine_device_from_handle(params->device)->funcs.p_vkGetShaderModuleCreateInfoIdentifierEXT(wine_device_from_handle(params->device)->device, &pCreateInfo_host, &pIdentifier_host);
40060     convert_VkShaderModuleIdentifierEXT_host_to_win32(&pIdentifier_host, params->pIdentifier);
40061     free_conversion_context(&ctx);
40062     return STATUS_SUCCESS;
40063 }
40064
40065 #endif /* USE_STRUCT_CONVERSION */
40066
40067 #if !defined(USE_STRUCT_CONVERSION)
40068
40069 static NTSTATUS thunk64_vkGetShaderModuleIdentifierEXT(void *args)
40070 {
40071     struct vkGetShaderModuleIdentifierEXT_params *params = args;
40072
40073     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pIdentifier);
40074
40075     wine_device_from_handle(params->device)->funcs.p_vkGetShaderModuleIdentifierEXT(wine_device_from_handle(params->device)->device, params->shaderModule, params->pIdentifier);
40076     return STATUS_SUCCESS;
40077 }
40078
40079 #else /* USE_STRUCT_CONVERSION */
40080
40081 static NTSTATUS thunk32_vkGetShaderModuleIdentifierEXT(void *args)
40082 {
40083     struct
40084     {
40085         VkDevice device;
40086         VkShaderModule DECLSPEC_ALIGN(8) shaderModule;
40087         VkShaderModuleIdentifierEXT32 *pIdentifier;
40088     } *params = args;
40089     VkShaderModuleIdentifierEXT pIdentifier_host;
40090
40091     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pIdentifier);
40092
40093     convert_VkShaderModuleIdentifierEXT_win32_to_host(params->pIdentifier, &pIdentifier_host);
40094     wine_device_from_handle(params->device)->funcs.p_vkGetShaderModuleIdentifierEXT(wine_device_from_handle(params->device)->device, params->shaderModule, &pIdentifier_host);
40095     convert_VkShaderModuleIdentifierEXT_host_to_win32(&pIdentifier_host, params->pIdentifier);
40096     return STATUS_SUCCESS;
40097 }
40098
40099 #endif /* USE_STRUCT_CONVERSION */
40100
40101 #if !defined(USE_STRUCT_CONVERSION)
40102
40103 static NTSTATUS thunk64_vkGetSwapchainImagesKHR(void *args)
40104 {
40105     struct vkGetSwapchainImagesKHR_params *params = args;
40106
40107     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainImageCount, params->pSwapchainImages);
40108
40109     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSwapchainImagesKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->pSwapchainImageCount, params->pSwapchainImages);
40110     return STATUS_SUCCESS;
40111 }
40112
40113 #else /* USE_STRUCT_CONVERSION */
40114
40115 static NTSTATUS thunk32_vkGetSwapchainImagesKHR(void *args)
40116 {
40117     struct
40118     {
40119         VkDevice device;
40120         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
40121         uint32_t *pSwapchainImageCount;
40122         VkImage *pSwapchainImages;
40123         VkResult result;
40124     } *params = args;
40125
40126     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainImageCount, params->pSwapchainImages);
40127
40128     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSwapchainImagesKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->pSwapchainImageCount, params->pSwapchainImages);
40129     return STATUS_SUCCESS;
40130 }
40131
40132 #endif /* USE_STRUCT_CONVERSION */
40133
40134 #if !defined(USE_STRUCT_CONVERSION)
40135
40136 static NTSTATUS thunk64_vkGetValidationCacheDataEXT(void *args)
40137 {
40138     struct vkGetValidationCacheDataEXT_params *params = args;
40139
40140     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pDataSize, params->pData);
40141
40142     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetValidationCacheDataEXT(wine_device_from_handle(params->device)->device, params->validationCache, params->pDataSize, params->pData);
40143     return STATUS_SUCCESS;
40144 }
40145
40146 #else /* USE_STRUCT_CONVERSION */
40147
40148 static NTSTATUS thunk32_vkGetValidationCacheDataEXT(void *args)
40149 {
40150     struct
40151     {
40152         VkDevice device;
40153         VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
40154         size_t *pDataSize;
40155         void *pData;
40156         VkResult result;
40157     } *params = args;
40158
40159     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pDataSize, params->pData);
40160
40161     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetValidationCacheDataEXT(wine_device_from_handle(params->device)->device, params->validationCache, params->pDataSize, params->pData);
40162     return STATUS_SUCCESS;
40163 }
40164
40165 #endif /* USE_STRUCT_CONVERSION */
40166
40167 #if !defined(USE_STRUCT_CONVERSION)
40168
40169 static NTSTATUS thunk64_vkInitializePerformanceApiINTEL(void *args)
40170 {
40171     struct vkInitializePerformanceApiINTEL_params *params = args;
40172
40173     TRACE("%p, %p\n", params->device, params->pInitializeInfo);
40174
40175     params->result = wine_device_from_handle(params->device)->funcs.p_vkInitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device, params->pInitializeInfo);
40176     return STATUS_SUCCESS;
40177 }
40178
40179 #else /* USE_STRUCT_CONVERSION */
40180
40181 static NTSTATUS thunk32_vkInitializePerformanceApiINTEL(void *args)
40182 {
40183     struct
40184     {
40185         VkDevice device;
40186         const VkInitializePerformanceApiInfoINTEL32 *pInitializeInfo;
40187         VkResult result;
40188     } *params = args;
40189     VkInitializePerformanceApiInfoINTEL pInitializeInfo_host;
40190
40191     TRACE("%p, %p\n", params->device, params->pInitializeInfo);
40192
40193     convert_VkInitializePerformanceApiInfoINTEL_win32_to_host(params->pInitializeInfo, &pInitializeInfo_host);
40194     params->result = wine_device_from_handle(params->device)->funcs.p_vkInitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device, &pInitializeInfo_host);
40195     return STATUS_SUCCESS;
40196 }
40197
40198 #endif /* USE_STRUCT_CONVERSION */
40199
40200 #if !defined(USE_STRUCT_CONVERSION)
40201
40202 static NTSTATUS thunk64_vkInvalidateMappedMemoryRanges(void *args)
40203 {
40204     struct vkInvalidateMappedMemoryRanges_params *params = args;
40205
40206     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
40207
40208     params->result = wine_device_from_handle(params->device)->funcs.p_vkInvalidateMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, params->pMemoryRanges);
40209     return STATUS_SUCCESS;
40210 }
40211
40212 #else /* USE_STRUCT_CONVERSION */
40213
40214 static NTSTATUS thunk32_vkInvalidateMappedMemoryRanges(void *args)
40215 {
40216     struct
40217     {
40218         VkDevice device;
40219         uint32_t memoryRangeCount;
40220         const VkMappedMemoryRange32 *pMemoryRanges;
40221         VkResult result;
40222     } *params = args;
40223     const VkMappedMemoryRange *pMemoryRanges_host;
40224     struct conversion_context ctx;
40225
40226     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
40227
40228     init_conversion_context(&ctx);
40229     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win32_to_host(&ctx, params->pMemoryRanges, params->memoryRangeCount);
40230     params->result = wine_device_from_handle(params->device)->funcs.p_vkInvalidateMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, pMemoryRanges_host);
40231     free_conversion_context(&ctx);
40232     return STATUS_SUCCESS;
40233 }
40234
40235 #endif /* USE_STRUCT_CONVERSION */
40236
40237 #if !defined(USE_STRUCT_CONVERSION)
40238
40239 static NTSTATUS thunk64_vkMapMemory(void *args)
40240 {
40241     struct vkMapMemory_params *params = args;
40242
40243     TRACE("%p, 0x%s, 0x%s, 0x%s, %#x, %p\n", params->device, wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->size), params->flags, params->ppData);
40244
40245     params->result = wine_device_from_handle(params->device)->funcs.p_vkMapMemory(wine_device_from_handle(params->device)->device, params->memory, params->offset, params->size, params->flags, params->ppData);
40246     return STATUS_SUCCESS;
40247 }
40248
40249 #else /* USE_STRUCT_CONVERSION */
40250
40251 static NTSTATUS thunk32_vkMapMemory(void *args)
40252 {
40253     struct
40254     {
40255         VkDevice device;
40256         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
40257         VkDeviceSize DECLSPEC_ALIGN(8) offset;
40258         VkDeviceSize DECLSPEC_ALIGN(8) size;
40259         VkMemoryMapFlags flags;
40260         void **ppData;
40261         VkResult result;
40262     } *params = args;
40263
40264     TRACE("%p, 0x%s, 0x%s, 0x%s, %#x, %p\n", params->device, wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->size), params->flags, params->ppData);
40265
40266     params->result = wine_device_from_handle(params->device)->funcs.p_vkMapMemory(wine_device_from_handle(params->device)->device, params->memory, params->offset, params->size, params->flags, params->ppData);
40267     return STATUS_SUCCESS;
40268 }
40269
40270 #endif /* USE_STRUCT_CONVERSION */
40271
40272 #if !defined(USE_STRUCT_CONVERSION)
40273
40274 static NTSTATUS thunk64_vkMergePipelineCaches(void *args)
40275 {
40276     struct vkMergePipelineCaches_params *params = args;
40277
40278     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
40279
40280     params->result = wine_device_from_handle(params->device)->funcs.p_vkMergePipelineCaches(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
40281     return STATUS_SUCCESS;
40282 }
40283
40284 #else /* USE_STRUCT_CONVERSION */
40285
40286 static NTSTATUS thunk32_vkMergePipelineCaches(void *args)
40287 {
40288     struct
40289     {
40290         VkDevice device;
40291         VkPipelineCache DECLSPEC_ALIGN(8) dstCache;
40292         uint32_t srcCacheCount;
40293         const VkPipelineCache *pSrcCaches;
40294         VkResult result;
40295     } *params = args;
40296
40297     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
40298
40299     params->result = wine_device_from_handle(params->device)->funcs.p_vkMergePipelineCaches(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
40300     return STATUS_SUCCESS;
40301 }
40302
40303 #endif /* USE_STRUCT_CONVERSION */
40304
40305 #if !defined(USE_STRUCT_CONVERSION)
40306
40307 static NTSTATUS thunk64_vkMergeValidationCachesEXT(void *args)
40308 {
40309     struct vkMergeValidationCachesEXT_params *params = args;
40310
40311     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
40312
40313     params->result = wine_device_from_handle(params->device)->funcs.p_vkMergeValidationCachesEXT(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
40314     return STATUS_SUCCESS;
40315 }
40316
40317 #else /* USE_STRUCT_CONVERSION */
40318
40319 static NTSTATUS thunk32_vkMergeValidationCachesEXT(void *args)
40320 {
40321     struct
40322     {
40323         VkDevice device;
40324         VkValidationCacheEXT DECLSPEC_ALIGN(8) dstCache;
40325         uint32_t srcCacheCount;
40326         const VkValidationCacheEXT *pSrcCaches;
40327         VkResult result;
40328     } *params = args;
40329
40330     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
40331
40332     params->result = wine_device_from_handle(params->device)->funcs.p_vkMergeValidationCachesEXT(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
40333     return STATUS_SUCCESS;
40334 }
40335
40336 #endif /* USE_STRUCT_CONVERSION */
40337
40338 #if !defined(USE_STRUCT_CONVERSION)
40339
40340 static NTSTATUS thunk64_vkQueueBeginDebugUtilsLabelEXT(void *args)
40341 {
40342     struct vkQueueBeginDebugUtilsLabelEXT_params *params = args;
40343
40344     TRACE("%p, %p\n", params->queue, params->pLabelInfo);
40345
40346     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueBeginDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue, params->pLabelInfo);
40347     return STATUS_SUCCESS;
40348 }
40349
40350 #else /* USE_STRUCT_CONVERSION */
40351
40352 static NTSTATUS thunk32_vkQueueBeginDebugUtilsLabelEXT(void *args)
40353 {
40354     struct
40355     {
40356         VkQueue queue;
40357         const VkDebugUtilsLabelEXT32 *pLabelInfo;
40358     } *params = args;
40359     VkDebugUtilsLabelEXT pLabelInfo_host;
40360
40361     TRACE("%p, %p\n", params->queue, params->pLabelInfo);
40362
40363     convert_VkDebugUtilsLabelEXT_win32_to_host(params->pLabelInfo, &pLabelInfo_host);
40364     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueBeginDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue, &pLabelInfo_host);
40365     return STATUS_SUCCESS;
40366 }
40367
40368 #endif /* USE_STRUCT_CONVERSION */
40369
40370 #if !defined(USE_STRUCT_CONVERSION)
40371
40372 static NTSTATUS thunk64_vkQueueBindSparse(void *args)
40373 {
40374     struct vkQueueBindSparse_params *params = args;
40375
40376     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->bindInfoCount, params->pBindInfo, wine_dbgstr_longlong(params->fence));
40377
40378     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueBindSparse(wine_queue_from_handle(params->queue)->queue, params->bindInfoCount, params->pBindInfo, params->fence);
40379     return STATUS_SUCCESS;
40380 }
40381
40382 #else /* USE_STRUCT_CONVERSION */
40383
40384 static NTSTATUS thunk32_vkQueueBindSparse(void *args)
40385 {
40386     struct
40387     {
40388         VkQueue queue;
40389         uint32_t bindInfoCount;
40390         const VkBindSparseInfo32 *pBindInfo;
40391         VkFence DECLSPEC_ALIGN(8) fence;
40392         VkResult result;
40393     } *params = args;
40394     const VkBindSparseInfo *pBindInfo_host;
40395     struct conversion_context ctx;
40396
40397     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->bindInfoCount, params->pBindInfo, wine_dbgstr_longlong(params->fence));
40398
40399     init_conversion_context(&ctx);
40400     pBindInfo_host = convert_VkBindSparseInfo_array_win32_to_host(&ctx, params->pBindInfo, params->bindInfoCount);
40401     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueBindSparse(wine_queue_from_handle(params->queue)->queue, params->bindInfoCount, pBindInfo_host, params->fence);
40402     free_conversion_context(&ctx);
40403     return STATUS_SUCCESS;
40404 }
40405
40406 #endif /* USE_STRUCT_CONVERSION */
40407
40408 #if !defined(USE_STRUCT_CONVERSION)
40409
40410 static NTSTATUS thunk64_vkQueueEndDebugUtilsLabelEXT(void *args)
40411 {
40412     struct vkQueueEndDebugUtilsLabelEXT_params *params = args;
40413
40414     TRACE("%p\n", params->queue);
40415
40416     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueEndDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue);
40417     return STATUS_SUCCESS;
40418 }
40419
40420 #else /* USE_STRUCT_CONVERSION */
40421
40422 static NTSTATUS thunk32_vkQueueEndDebugUtilsLabelEXT(void *args)
40423 {
40424     struct
40425     {
40426         VkQueue queue;
40427     } *params = args;
40428
40429     TRACE("%p\n", params->queue);
40430
40431     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueEndDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue);
40432     return STATUS_SUCCESS;
40433 }
40434
40435 #endif /* USE_STRUCT_CONVERSION */
40436
40437 #if !defined(USE_STRUCT_CONVERSION)
40438
40439 static NTSTATUS thunk64_vkQueueInsertDebugUtilsLabelEXT(void *args)
40440 {
40441     struct vkQueueInsertDebugUtilsLabelEXT_params *params = args;
40442
40443     TRACE("%p, %p\n", params->queue, params->pLabelInfo);
40444
40445     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueInsertDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue, params->pLabelInfo);
40446     return STATUS_SUCCESS;
40447 }
40448
40449 #else /* USE_STRUCT_CONVERSION */
40450
40451 static NTSTATUS thunk32_vkQueueInsertDebugUtilsLabelEXT(void *args)
40452 {
40453     struct
40454     {
40455         VkQueue queue;
40456         const VkDebugUtilsLabelEXT32 *pLabelInfo;
40457     } *params = args;
40458     VkDebugUtilsLabelEXT pLabelInfo_host;
40459
40460     TRACE("%p, %p\n", params->queue, params->pLabelInfo);
40461
40462     convert_VkDebugUtilsLabelEXT_win32_to_host(params->pLabelInfo, &pLabelInfo_host);
40463     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueInsertDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue, &pLabelInfo_host);
40464     return STATUS_SUCCESS;
40465 }
40466
40467 #endif /* USE_STRUCT_CONVERSION */
40468
40469 #if !defined(USE_STRUCT_CONVERSION)
40470
40471 static NTSTATUS thunk64_vkQueuePresentKHR(void *args)
40472 {
40473     struct vkQueuePresentKHR_params *params = args;
40474
40475     TRACE("%p, %p\n", params->queue, params->pPresentInfo);
40476
40477     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueuePresentKHR(wine_queue_from_handle(params->queue)->queue, params->pPresentInfo);
40478     return STATUS_SUCCESS;
40479 }
40480
40481 #else /* USE_STRUCT_CONVERSION */
40482
40483 static NTSTATUS thunk32_vkQueuePresentKHR(void *args)
40484 {
40485     struct
40486     {
40487         VkQueue queue;
40488         const VkPresentInfoKHR32 *pPresentInfo;
40489         VkResult result;
40490     } *params = args;
40491     VkPresentInfoKHR pPresentInfo_host;
40492     struct conversion_context ctx;
40493
40494     TRACE("%p, %p\n", params->queue, params->pPresentInfo);
40495
40496     init_conversion_context(&ctx);
40497     convert_VkPresentInfoKHR_win32_to_host(&ctx, params->pPresentInfo, &pPresentInfo_host);
40498     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueuePresentKHR(wine_queue_from_handle(params->queue)->queue, &pPresentInfo_host);
40499     free_conversion_context(&ctx);
40500     return STATUS_SUCCESS;
40501 }
40502
40503 #endif /* USE_STRUCT_CONVERSION */
40504
40505 #if !defined(USE_STRUCT_CONVERSION)
40506
40507 static NTSTATUS thunk64_vkQueueSetPerformanceConfigurationINTEL(void *args)
40508 {
40509     struct vkQueueSetPerformanceConfigurationINTEL_params *params = args;
40510
40511     TRACE("%p, 0x%s\n", params->queue, wine_dbgstr_longlong(params->configuration));
40512
40513     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSetPerformanceConfigurationINTEL(wine_queue_from_handle(params->queue)->queue, params->configuration);
40514     return STATUS_SUCCESS;
40515 }
40516
40517 #else /* USE_STRUCT_CONVERSION */
40518
40519 static NTSTATUS thunk32_vkQueueSetPerformanceConfigurationINTEL(void *args)
40520 {
40521     struct
40522     {
40523         VkQueue queue;
40524         VkPerformanceConfigurationINTEL DECLSPEC_ALIGN(8) configuration;
40525         VkResult result;
40526     } *params = args;
40527
40528     TRACE("%p, 0x%s\n", params->queue, wine_dbgstr_longlong(params->configuration));
40529
40530     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSetPerformanceConfigurationINTEL(wine_queue_from_handle(params->queue)->queue, params->configuration);
40531     return STATUS_SUCCESS;
40532 }
40533
40534 #endif /* USE_STRUCT_CONVERSION */
40535
40536 #if !defined(USE_STRUCT_CONVERSION)
40537
40538 static NTSTATUS thunk64_vkQueueSubmit(void *args)
40539 {
40540     struct vkQueueSubmit_params *params = args;
40541     const VkSubmitInfo *pSubmits_host;
40542     struct conversion_context ctx;
40543
40544     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
40545
40546     init_conversion_context(&ctx);
40547     pSubmits_host = convert_VkSubmitInfo_array_win64_to_host(&ctx, params->pSubmits, params->submitCount);
40548     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
40549     free_conversion_context(&ctx);
40550     return STATUS_SUCCESS;
40551 }
40552
40553 #else /* USE_STRUCT_CONVERSION */
40554
40555 static NTSTATUS thunk32_vkQueueSubmit(void *args)
40556 {
40557     struct
40558     {
40559         VkQueue queue;
40560         uint32_t submitCount;
40561         const VkSubmitInfo32 *pSubmits;
40562         VkFence DECLSPEC_ALIGN(8) fence;
40563         VkResult result;
40564     } *params = args;
40565     const VkSubmitInfo *pSubmits_host;
40566     struct conversion_context ctx;
40567
40568     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
40569
40570     init_conversion_context(&ctx);
40571     pSubmits_host = convert_VkSubmitInfo_array_win32_to_host(&ctx, params->pSubmits, params->submitCount);
40572     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
40573     free_conversion_context(&ctx);
40574     return STATUS_SUCCESS;
40575 }
40576
40577 #endif /* USE_STRUCT_CONVERSION */
40578
40579 #if !defined(USE_STRUCT_CONVERSION)
40580
40581 static NTSTATUS thunk64_vkQueueSubmit2(void *args)
40582 {
40583     struct vkQueueSubmit2_params *params = args;
40584     const VkSubmitInfo2 *pSubmits_host;
40585     struct conversion_context ctx;
40586
40587     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
40588
40589     init_conversion_context(&ctx);
40590     pSubmits_host = convert_VkSubmitInfo2_array_win64_to_host(&ctx, params->pSubmits, params->submitCount);
40591     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit2(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
40592     free_conversion_context(&ctx);
40593     return STATUS_SUCCESS;
40594 }
40595
40596 #else /* USE_STRUCT_CONVERSION */
40597
40598 static NTSTATUS thunk32_vkQueueSubmit2(void *args)
40599 {
40600     struct
40601     {
40602         VkQueue queue;
40603         uint32_t submitCount;
40604         const VkSubmitInfo232 *pSubmits;
40605         VkFence DECLSPEC_ALIGN(8) fence;
40606         VkResult result;
40607     } *params = args;
40608     const VkSubmitInfo2 *pSubmits_host;
40609     struct conversion_context ctx;
40610
40611     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
40612
40613     init_conversion_context(&ctx);
40614     pSubmits_host = convert_VkSubmitInfo2_array_win32_to_host(&ctx, params->pSubmits, params->submitCount);
40615     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit2(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
40616     free_conversion_context(&ctx);
40617     return STATUS_SUCCESS;
40618 }
40619
40620 #endif /* USE_STRUCT_CONVERSION */
40621
40622 #if !defined(USE_STRUCT_CONVERSION)
40623
40624 static NTSTATUS thunk64_vkQueueSubmit2KHR(void *args)
40625 {
40626     struct vkQueueSubmit2KHR_params *params = args;
40627     const VkSubmitInfo2 *pSubmits_host;
40628     struct conversion_context ctx;
40629
40630     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
40631
40632     init_conversion_context(&ctx);
40633     pSubmits_host = convert_VkSubmitInfo2_array_win64_to_host(&ctx, params->pSubmits, params->submitCount);
40634     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit2KHR(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
40635     free_conversion_context(&ctx);
40636     return STATUS_SUCCESS;
40637 }
40638
40639 #else /* USE_STRUCT_CONVERSION */
40640
40641 static NTSTATUS thunk32_vkQueueSubmit2KHR(void *args)
40642 {
40643     struct
40644     {
40645         VkQueue queue;
40646         uint32_t submitCount;
40647         const VkSubmitInfo232 *pSubmits;
40648         VkFence DECLSPEC_ALIGN(8) fence;
40649         VkResult result;
40650     } *params = args;
40651     const VkSubmitInfo2 *pSubmits_host;
40652     struct conversion_context ctx;
40653
40654     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
40655
40656     init_conversion_context(&ctx);
40657     pSubmits_host = convert_VkSubmitInfo2_array_win32_to_host(&ctx, params->pSubmits, params->submitCount);
40658     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit2KHR(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
40659     free_conversion_context(&ctx);
40660     return STATUS_SUCCESS;
40661 }
40662
40663 #endif /* USE_STRUCT_CONVERSION */
40664
40665 #if !defined(USE_STRUCT_CONVERSION)
40666
40667 static NTSTATUS thunk64_vkQueueWaitIdle(void *args)
40668 {
40669     struct vkQueueWaitIdle_params *params = args;
40670
40671     TRACE("%p\n", params->queue);
40672
40673     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueWaitIdle(wine_queue_from_handle(params->queue)->queue);
40674     return STATUS_SUCCESS;
40675 }
40676
40677 #else /* USE_STRUCT_CONVERSION */
40678
40679 static NTSTATUS thunk32_vkQueueWaitIdle(void *args)
40680 {
40681     struct
40682     {
40683         VkQueue queue;
40684         VkResult result;
40685     } *params = args;
40686
40687     TRACE("%p\n", params->queue);
40688
40689     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueWaitIdle(wine_queue_from_handle(params->queue)->queue);
40690     return STATUS_SUCCESS;
40691 }
40692
40693 #endif /* USE_STRUCT_CONVERSION */
40694
40695 #if !defined(USE_STRUCT_CONVERSION)
40696
40697 static NTSTATUS thunk64_vkReleasePerformanceConfigurationINTEL(void *args)
40698 {
40699     struct vkReleasePerformanceConfigurationINTEL_params *params = args;
40700
40701     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->configuration));
40702
40703     params->result = wine_device_from_handle(params->device)->funcs.p_vkReleasePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->configuration);
40704     return STATUS_SUCCESS;
40705 }
40706
40707 #else /* USE_STRUCT_CONVERSION */
40708
40709 static NTSTATUS thunk32_vkReleasePerformanceConfigurationINTEL(void *args)
40710 {
40711     struct
40712     {
40713         VkDevice device;
40714         VkPerformanceConfigurationINTEL DECLSPEC_ALIGN(8) configuration;
40715         VkResult result;
40716     } *params = args;
40717
40718     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->configuration));
40719
40720     params->result = wine_device_from_handle(params->device)->funcs.p_vkReleasePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->configuration);
40721     return STATUS_SUCCESS;
40722 }
40723
40724 #endif /* USE_STRUCT_CONVERSION */
40725
40726 #if !defined(USE_STRUCT_CONVERSION)
40727
40728 static NTSTATUS thunk64_vkReleaseProfilingLockKHR(void *args)
40729 {
40730     struct vkReleaseProfilingLockKHR_params *params = args;
40731
40732     TRACE("%p\n", params->device);
40733
40734     wine_device_from_handle(params->device)->funcs.p_vkReleaseProfilingLockKHR(wine_device_from_handle(params->device)->device);
40735     return STATUS_SUCCESS;
40736 }
40737
40738 #else /* USE_STRUCT_CONVERSION */
40739
40740 static NTSTATUS thunk32_vkReleaseProfilingLockKHR(void *args)
40741 {
40742     struct
40743     {
40744         VkDevice device;
40745     } *params = args;
40746
40747     TRACE("%p\n", params->device);
40748
40749     wine_device_from_handle(params->device)->funcs.p_vkReleaseProfilingLockKHR(wine_device_from_handle(params->device)->device);
40750     return STATUS_SUCCESS;
40751 }
40752
40753 #endif /* USE_STRUCT_CONVERSION */
40754
40755 #if !defined(USE_STRUCT_CONVERSION)
40756
40757 static NTSTATUS thunk64_vkResetCommandBuffer(void *args)
40758 {
40759     struct vkResetCommandBuffer_params *params = args;
40760
40761     TRACE("%p, %#x\n", params->commandBuffer, params->flags);
40762
40763     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkResetCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->flags);
40764     return STATUS_SUCCESS;
40765 }
40766
40767 #else /* USE_STRUCT_CONVERSION */
40768
40769 static NTSTATUS thunk32_vkResetCommandBuffer(void *args)
40770 {
40771     struct
40772     {
40773         VkCommandBuffer commandBuffer;
40774         VkCommandBufferResetFlags flags;
40775         VkResult result;
40776     } *params = args;
40777
40778     TRACE("%p, %#x\n", params->commandBuffer, params->flags);
40779
40780     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkResetCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->flags);
40781     return STATUS_SUCCESS;
40782 }
40783
40784 #endif /* USE_STRUCT_CONVERSION */
40785
40786 #if !defined(USE_STRUCT_CONVERSION)
40787
40788 static NTSTATUS thunk64_vkResetCommandPool(void *args)
40789 {
40790     struct vkResetCommandPool_params *params = args;
40791
40792     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
40793
40794     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetCommandPool(wine_device_from_handle(params->device)->device, wine_cmd_pool_from_handle(params->commandPool)->command_pool, params->flags);
40795     return STATUS_SUCCESS;
40796 }
40797
40798 #else /* USE_STRUCT_CONVERSION */
40799
40800 static NTSTATUS thunk32_vkResetCommandPool(void *args)
40801 {
40802     struct
40803     {
40804         VkDevice device;
40805         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
40806         VkCommandPoolResetFlags flags;
40807         VkResult result;
40808     } *params = args;
40809
40810     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
40811
40812     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetCommandPool(wine_device_from_handle(params->device)->device, wine_cmd_pool_from_handle(params->commandPool)->command_pool, params->flags);
40813     return STATUS_SUCCESS;
40814 }
40815
40816 #endif /* USE_STRUCT_CONVERSION */
40817
40818 #if !defined(USE_STRUCT_CONVERSION)
40819
40820 static NTSTATUS thunk64_vkResetDescriptorPool(void *args)
40821 {
40822     struct vkResetDescriptorPool_params *params = args;
40823
40824     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->flags);
40825
40826     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, params->flags);
40827     return STATUS_SUCCESS;
40828 }
40829
40830 #else /* USE_STRUCT_CONVERSION */
40831
40832 static NTSTATUS thunk32_vkResetDescriptorPool(void *args)
40833 {
40834     struct
40835     {
40836         VkDevice device;
40837         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
40838         VkDescriptorPoolResetFlags flags;
40839         VkResult result;
40840     } *params = args;
40841
40842     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->flags);
40843
40844     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, params->flags);
40845     return STATUS_SUCCESS;
40846 }
40847
40848 #endif /* USE_STRUCT_CONVERSION */
40849
40850 #if !defined(USE_STRUCT_CONVERSION)
40851
40852 static NTSTATUS thunk64_vkResetEvent(void *args)
40853 {
40854     struct vkResetEvent_params *params = args;
40855
40856     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
40857
40858     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetEvent(wine_device_from_handle(params->device)->device, params->event);
40859     return STATUS_SUCCESS;
40860 }
40861
40862 #else /* USE_STRUCT_CONVERSION */
40863
40864 static NTSTATUS thunk32_vkResetEvent(void *args)
40865 {
40866     struct
40867     {
40868         VkDevice device;
40869         VkEvent DECLSPEC_ALIGN(8) event;
40870         VkResult result;
40871     } *params = args;
40872
40873     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
40874
40875     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetEvent(wine_device_from_handle(params->device)->device, params->event);
40876     return STATUS_SUCCESS;
40877 }
40878
40879 #endif /* USE_STRUCT_CONVERSION */
40880
40881 #if !defined(USE_STRUCT_CONVERSION)
40882
40883 static NTSTATUS thunk64_vkResetFences(void *args)
40884 {
40885     struct vkResetFences_params *params = args;
40886
40887     TRACE("%p, %u, %p\n", params->device, params->fenceCount, params->pFences);
40888
40889     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences);
40890     return STATUS_SUCCESS;
40891 }
40892
40893 #else /* USE_STRUCT_CONVERSION */
40894
40895 static NTSTATUS thunk32_vkResetFences(void *args)
40896 {
40897     struct
40898     {
40899         VkDevice device;
40900         uint32_t fenceCount;
40901         const VkFence *pFences;
40902         VkResult result;
40903     } *params = args;
40904
40905     TRACE("%p, %u, %p\n", params->device, params->fenceCount, params->pFences);
40906
40907     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences);
40908     return STATUS_SUCCESS;
40909 }
40910
40911 #endif /* USE_STRUCT_CONVERSION */
40912
40913 #if !defined(USE_STRUCT_CONVERSION)
40914
40915 static NTSTATUS thunk64_vkResetQueryPool(void *args)
40916 {
40917     struct vkResetQueryPool_params *params = args;
40918
40919     TRACE("%p, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
40920
40921     wine_device_from_handle(params->device)->funcs.p_vkResetQueryPool(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount);
40922     return STATUS_SUCCESS;
40923 }
40924
40925 #else /* USE_STRUCT_CONVERSION */
40926
40927 static NTSTATUS thunk32_vkResetQueryPool(void *args)
40928 {
40929     struct
40930     {
40931         VkDevice device;
40932         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
40933         uint32_t firstQuery;
40934         uint32_t queryCount;
40935     } *params = args;
40936
40937     TRACE("%p, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
40938
40939     wine_device_from_handle(params->device)->funcs.p_vkResetQueryPool(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount);
40940     return STATUS_SUCCESS;
40941 }
40942
40943 #endif /* USE_STRUCT_CONVERSION */
40944
40945 #if !defined(USE_STRUCT_CONVERSION)
40946
40947 static NTSTATUS thunk64_vkResetQueryPoolEXT(void *args)
40948 {
40949     struct vkResetQueryPoolEXT_params *params = args;
40950
40951     TRACE("%p, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
40952
40953     wine_device_from_handle(params->device)->funcs.p_vkResetQueryPoolEXT(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount);
40954     return STATUS_SUCCESS;
40955 }
40956
40957 #else /* USE_STRUCT_CONVERSION */
40958
40959 static NTSTATUS thunk32_vkResetQueryPoolEXT(void *args)
40960 {
40961     struct
40962     {
40963         VkDevice device;
40964         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
40965         uint32_t firstQuery;
40966         uint32_t queryCount;
40967     } *params = args;
40968
40969     TRACE("%p, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
40970
40971     wine_device_from_handle(params->device)->funcs.p_vkResetQueryPoolEXT(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount);
40972     return STATUS_SUCCESS;
40973 }
40974
40975 #endif /* USE_STRUCT_CONVERSION */
40976
40977 #if !defined(USE_STRUCT_CONVERSION)
40978
40979 static NTSTATUS thunk64_vkSetDebugUtilsObjectNameEXT(void *args)
40980 {
40981     struct vkSetDebugUtilsObjectNameEXT_params *params = args;
40982     VkDebugUtilsObjectNameInfoEXT pNameInfo_host;
40983
40984     TRACE("%p, %p\n", params->device, params->pNameInfo);
40985
40986     convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(params->pNameInfo, &pNameInfo_host);
40987     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
40988     return STATUS_SUCCESS;
40989 }
40990
40991 #else /* USE_STRUCT_CONVERSION */
40992
40993 static NTSTATUS thunk32_vkSetDebugUtilsObjectNameEXT(void *args)
40994 {
40995     struct
40996     {
40997         VkDevice device;
40998         const VkDebugUtilsObjectNameInfoEXT32 *pNameInfo;
40999         VkResult result;
41000     } *params = args;
41001     VkDebugUtilsObjectNameInfoEXT pNameInfo_host;
41002
41003     TRACE("%p, %p\n", params->device, params->pNameInfo);
41004
41005     convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(params->pNameInfo, &pNameInfo_host);
41006     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
41007     return STATUS_SUCCESS;
41008 }
41009
41010 #endif /* USE_STRUCT_CONVERSION */
41011
41012 #if !defined(USE_STRUCT_CONVERSION)
41013
41014 static NTSTATUS thunk64_vkSetDebugUtilsObjectTagEXT(void *args)
41015 {
41016     struct vkSetDebugUtilsObjectTagEXT_params *params = args;
41017     VkDebugUtilsObjectTagInfoEXT pTagInfo_host;
41018
41019     TRACE("%p, %p\n", params->device, params->pTagInfo);
41020
41021     convert_VkDebugUtilsObjectTagInfoEXT_win64_to_host(params->pTagInfo, &pTagInfo_host);
41022     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
41023     return STATUS_SUCCESS;
41024 }
41025
41026 #else /* USE_STRUCT_CONVERSION */
41027
41028 static NTSTATUS thunk32_vkSetDebugUtilsObjectTagEXT(void *args)
41029 {
41030     struct
41031     {
41032         VkDevice device;
41033         const VkDebugUtilsObjectTagInfoEXT32 *pTagInfo;
41034         VkResult result;
41035     } *params = args;
41036     VkDebugUtilsObjectTagInfoEXT pTagInfo_host;
41037
41038     TRACE("%p, %p\n", params->device, params->pTagInfo);
41039
41040     convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host(params->pTagInfo, &pTagInfo_host);
41041     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
41042     return STATUS_SUCCESS;
41043 }
41044
41045 #endif /* USE_STRUCT_CONVERSION */
41046
41047 #if !defined(USE_STRUCT_CONVERSION)
41048
41049 static NTSTATUS thunk64_vkSetDeviceMemoryPriorityEXT(void *args)
41050 {
41051     struct vkSetDeviceMemoryPriorityEXT_params *params = args;
41052
41053     TRACE("%p, 0x%s, %f\n", params->device, wine_dbgstr_longlong(params->memory), params->priority);
41054
41055     wine_device_from_handle(params->device)->funcs.p_vkSetDeviceMemoryPriorityEXT(wine_device_from_handle(params->device)->device, params->memory, params->priority);
41056     return STATUS_SUCCESS;
41057 }
41058
41059 #else /* USE_STRUCT_CONVERSION */
41060
41061 static NTSTATUS thunk32_vkSetDeviceMemoryPriorityEXT(void *args)
41062 {
41063     struct
41064     {
41065         VkDevice device;
41066         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
41067         float priority;
41068     } *params = args;
41069
41070     TRACE("%p, 0x%s, %f\n", params->device, wine_dbgstr_longlong(params->memory), params->priority);
41071
41072     wine_device_from_handle(params->device)->funcs.p_vkSetDeviceMemoryPriorityEXT(wine_device_from_handle(params->device)->device, params->memory, params->priority);
41073     return STATUS_SUCCESS;
41074 }
41075
41076 #endif /* USE_STRUCT_CONVERSION */
41077
41078 #if !defined(USE_STRUCT_CONVERSION)
41079
41080 static NTSTATUS thunk64_vkSetEvent(void *args)
41081 {
41082     struct vkSetEvent_params *params = args;
41083
41084     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
41085
41086     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetEvent(wine_device_from_handle(params->device)->device, params->event);
41087     return STATUS_SUCCESS;
41088 }
41089
41090 #else /* USE_STRUCT_CONVERSION */
41091
41092 static NTSTATUS thunk32_vkSetEvent(void *args)
41093 {
41094     struct
41095     {
41096         VkDevice device;
41097         VkEvent DECLSPEC_ALIGN(8) event;
41098         VkResult result;
41099     } *params = args;
41100
41101     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
41102
41103     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetEvent(wine_device_from_handle(params->device)->device, params->event);
41104     return STATUS_SUCCESS;
41105 }
41106
41107 #endif /* USE_STRUCT_CONVERSION */
41108
41109 #if !defined(USE_STRUCT_CONVERSION)
41110
41111 static NTSTATUS thunk64_vkSetPrivateData(void *args)
41112 {
41113     struct vkSetPrivateData_params *params = args;
41114
41115     TRACE("%p, %#x, 0x%s, 0x%s, 0x%s\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), wine_dbgstr_longlong(params->data));
41116
41117     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetPrivateData(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->data);
41118     return STATUS_SUCCESS;
41119 }
41120
41121 #else /* USE_STRUCT_CONVERSION */
41122
41123 static NTSTATUS thunk32_vkSetPrivateData(void *args)
41124 {
41125     struct
41126     {
41127         VkDevice device;
41128         VkObjectType objectType;
41129         uint64_t DECLSPEC_ALIGN(8) objectHandle;
41130         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
41131         uint64_t DECLSPEC_ALIGN(8) data;
41132         VkResult result;
41133     } *params = args;
41134
41135     TRACE("%p, %#x, 0x%s, 0x%s, 0x%s\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), wine_dbgstr_longlong(params->data));
41136
41137     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetPrivateData(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->data);
41138     return STATUS_SUCCESS;
41139 }
41140
41141 #endif /* USE_STRUCT_CONVERSION */
41142
41143 #if !defined(USE_STRUCT_CONVERSION)
41144
41145 static NTSTATUS thunk64_vkSetPrivateDataEXT(void *args)
41146 {
41147     struct vkSetPrivateDataEXT_params *params = args;
41148
41149     TRACE("%p, %#x, 0x%s, 0x%s, 0x%s\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), wine_dbgstr_longlong(params->data));
41150
41151     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetPrivateDataEXT(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->data);
41152     return STATUS_SUCCESS;
41153 }
41154
41155 #else /* USE_STRUCT_CONVERSION */
41156
41157 static NTSTATUS thunk32_vkSetPrivateDataEXT(void *args)
41158 {
41159     struct
41160     {
41161         VkDevice device;
41162         VkObjectType objectType;
41163         uint64_t DECLSPEC_ALIGN(8) objectHandle;
41164         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
41165         uint64_t DECLSPEC_ALIGN(8) data;
41166         VkResult result;
41167     } *params = args;
41168
41169     TRACE("%p, %#x, 0x%s, 0x%s, 0x%s\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), wine_dbgstr_longlong(params->data));
41170
41171     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetPrivateDataEXT(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->data);
41172     return STATUS_SUCCESS;
41173 }
41174
41175 #endif /* USE_STRUCT_CONVERSION */
41176
41177 #if !defined(USE_STRUCT_CONVERSION)
41178
41179 static NTSTATUS thunk64_vkSignalSemaphore(void *args)
41180 {
41181     struct vkSignalSemaphore_params *params = args;
41182
41183     TRACE("%p, %p\n", params->device, params->pSignalInfo);
41184
41185     params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphore(wine_device_from_handle(params->device)->device, params->pSignalInfo);
41186     return STATUS_SUCCESS;
41187 }
41188
41189 #else /* USE_STRUCT_CONVERSION */
41190
41191 static NTSTATUS thunk32_vkSignalSemaphore(void *args)
41192 {
41193     struct
41194     {
41195         VkDevice device;
41196         const VkSemaphoreSignalInfo32 *pSignalInfo;
41197         VkResult result;
41198     } *params = args;
41199     VkSemaphoreSignalInfo pSignalInfo_host;
41200
41201     TRACE("%p, %p\n", params->device, params->pSignalInfo);
41202
41203     convert_VkSemaphoreSignalInfo_win32_to_host(params->pSignalInfo, &pSignalInfo_host);
41204     params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphore(wine_device_from_handle(params->device)->device, &pSignalInfo_host);
41205     return STATUS_SUCCESS;
41206 }
41207
41208 #endif /* USE_STRUCT_CONVERSION */
41209
41210 #if !defined(USE_STRUCT_CONVERSION)
41211
41212 static NTSTATUS thunk64_vkSignalSemaphoreKHR(void *args)
41213 {
41214     struct vkSignalSemaphoreKHR_params *params = args;
41215
41216     TRACE("%p, %p\n", params->device, params->pSignalInfo);
41217
41218     params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphoreKHR(wine_device_from_handle(params->device)->device, params->pSignalInfo);
41219     return STATUS_SUCCESS;
41220 }
41221
41222 #else /* USE_STRUCT_CONVERSION */
41223
41224 static NTSTATUS thunk32_vkSignalSemaphoreKHR(void *args)
41225 {
41226     struct
41227     {
41228         VkDevice device;
41229         const VkSemaphoreSignalInfo32 *pSignalInfo;
41230         VkResult result;
41231     } *params = args;
41232     VkSemaphoreSignalInfo pSignalInfo_host;
41233
41234     TRACE("%p, %p\n", params->device, params->pSignalInfo);
41235
41236     convert_VkSemaphoreSignalInfo_win32_to_host(params->pSignalInfo, &pSignalInfo_host);
41237     params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphoreKHR(wine_device_from_handle(params->device)->device, &pSignalInfo_host);
41238     return STATUS_SUCCESS;
41239 }
41240
41241 #endif /* USE_STRUCT_CONVERSION */
41242
41243 #if !defined(USE_STRUCT_CONVERSION)
41244
41245 static NTSTATUS thunk64_vkSubmitDebugUtilsMessageEXT(void *args)
41246 {
41247     struct vkSubmitDebugUtilsMessageEXT_params *params = args;
41248     VkDebugUtilsMessengerCallbackDataEXT pCallbackData_host;
41249     struct conversion_context ctx;
41250
41251     TRACE("%p, %#x, %#x, %p\n", params->instance, params->messageSeverity, params->messageTypes, params->pCallbackData);
41252
41253     init_conversion_context(&ctx);
41254     convert_VkDebugUtilsMessengerCallbackDataEXT_win64_to_host(&ctx, params->pCallbackData, &pCallbackData_host);
41255     wine_instance_from_handle(params->instance)->funcs.p_vkSubmitDebugUtilsMessageEXT(wine_instance_from_handle(params->instance)->instance, params->messageSeverity, params->messageTypes, &pCallbackData_host);
41256     free_conversion_context(&ctx);
41257     return STATUS_SUCCESS;
41258 }
41259
41260 #else /* USE_STRUCT_CONVERSION */
41261
41262 static NTSTATUS thunk32_vkSubmitDebugUtilsMessageEXT(void *args)
41263 {
41264     struct
41265     {
41266         VkInstance instance;
41267         VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity;
41268         VkDebugUtilsMessageTypeFlagsEXT messageTypes;
41269         const VkDebugUtilsMessengerCallbackDataEXT32 *pCallbackData;
41270     } *params = args;
41271     VkDebugUtilsMessengerCallbackDataEXT pCallbackData_host;
41272     struct conversion_context ctx;
41273
41274     TRACE("%p, %#x, %#x, %p\n", params->instance, params->messageSeverity, params->messageTypes, params->pCallbackData);
41275
41276     init_conversion_context(&ctx);
41277     convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(&ctx, params->pCallbackData, &pCallbackData_host);
41278     wine_instance_from_handle(params->instance)->funcs.p_vkSubmitDebugUtilsMessageEXT(wine_instance_from_handle(params->instance)->instance, params->messageSeverity, params->messageTypes, &pCallbackData_host);
41279     free_conversion_context(&ctx);
41280     return STATUS_SUCCESS;
41281 }
41282
41283 #endif /* USE_STRUCT_CONVERSION */
41284
41285 #if !defined(USE_STRUCT_CONVERSION)
41286
41287 static NTSTATUS thunk64_vkTrimCommandPool(void *args)
41288 {
41289     struct vkTrimCommandPool_params *params = args;
41290
41291     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
41292
41293     wine_device_from_handle(params->device)->funcs.p_vkTrimCommandPool(wine_device_from_handle(params->device)->device, wine_cmd_pool_from_handle(params->commandPool)->command_pool, params->flags);
41294     return STATUS_SUCCESS;
41295 }
41296
41297 #else /* USE_STRUCT_CONVERSION */
41298
41299 static NTSTATUS thunk32_vkTrimCommandPool(void *args)
41300 {
41301     struct
41302     {
41303         VkDevice device;
41304         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
41305         VkCommandPoolTrimFlags flags;
41306     } *params = args;
41307
41308     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
41309
41310     wine_device_from_handle(params->device)->funcs.p_vkTrimCommandPool(wine_device_from_handle(params->device)->device, wine_cmd_pool_from_handle(params->commandPool)->command_pool, params->flags);
41311     return STATUS_SUCCESS;
41312 }
41313
41314 #endif /* USE_STRUCT_CONVERSION */
41315
41316 #if !defined(USE_STRUCT_CONVERSION)
41317
41318 static NTSTATUS thunk64_vkTrimCommandPoolKHR(void *args)
41319 {
41320     struct vkTrimCommandPoolKHR_params *params = args;
41321
41322     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
41323
41324     wine_device_from_handle(params->device)->funcs.p_vkTrimCommandPoolKHR(wine_device_from_handle(params->device)->device, wine_cmd_pool_from_handle(params->commandPool)->command_pool, params->flags);
41325     return STATUS_SUCCESS;
41326 }
41327
41328 #else /* USE_STRUCT_CONVERSION */
41329
41330 static NTSTATUS thunk32_vkTrimCommandPoolKHR(void *args)
41331 {
41332     struct
41333     {
41334         VkDevice device;
41335         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
41336         VkCommandPoolTrimFlags flags;
41337     } *params = args;
41338
41339     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
41340
41341     wine_device_from_handle(params->device)->funcs.p_vkTrimCommandPoolKHR(wine_device_from_handle(params->device)->device, wine_cmd_pool_from_handle(params->commandPool)->command_pool, params->flags);
41342     return STATUS_SUCCESS;
41343 }
41344
41345 #endif /* USE_STRUCT_CONVERSION */
41346
41347 #if !defined(USE_STRUCT_CONVERSION)
41348
41349 static NTSTATUS thunk64_vkUninitializePerformanceApiINTEL(void *args)
41350 {
41351     struct vkUninitializePerformanceApiINTEL_params *params = args;
41352
41353     TRACE("%p\n", params->device);
41354
41355     wine_device_from_handle(params->device)->funcs.p_vkUninitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device);
41356     return STATUS_SUCCESS;
41357 }
41358
41359 #else /* USE_STRUCT_CONVERSION */
41360
41361 static NTSTATUS thunk32_vkUninitializePerformanceApiINTEL(void *args)
41362 {
41363     struct
41364     {
41365         VkDevice device;
41366     } *params = args;
41367
41368     TRACE("%p\n", params->device);
41369
41370     wine_device_from_handle(params->device)->funcs.p_vkUninitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device);
41371     return STATUS_SUCCESS;
41372 }
41373
41374 #endif /* USE_STRUCT_CONVERSION */
41375
41376 #if !defined(USE_STRUCT_CONVERSION)
41377
41378 static NTSTATUS thunk64_vkUnmapMemory(void *args)
41379 {
41380     struct vkUnmapMemory_params *params = args;
41381
41382     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->memory));
41383
41384     wine_device_from_handle(params->device)->funcs.p_vkUnmapMemory(wine_device_from_handle(params->device)->device, params->memory);
41385     return STATUS_SUCCESS;
41386 }
41387
41388 #else /* USE_STRUCT_CONVERSION */
41389
41390 static NTSTATUS thunk32_vkUnmapMemory(void *args)
41391 {
41392     struct
41393     {
41394         VkDevice device;
41395         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
41396     } *params = args;
41397
41398     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->memory));
41399
41400     wine_device_from_handle(params->device)->funcs.p_vkUnmapMemory(wine_device_from_handle(params->device)->device, params->memory);
41401     return STATUS_SUCCESS;
41402 }
41403
41404 #endif /* USE_STRUCT_CONVERSION */
41405
41406 #if !defined(USE_STRUCT_CONVERSION)
41407
41408 static NTSTATUS thunk64_vkUpdateDescriptorSetWithTemplate(void *args)
41409 {
41410     struct vkUpdateDescriptorSetWithTemplate_params *params = args;
41411
41412     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
41413
41414     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplate(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
41415     return STATUS_SUCCESS;
41416 }
41417
41418 #else /* USE_STRUCT_CONVERSION */
41419
41420 static NTSTATUS thunk32_vkUpdateDescriptorSetWithTemplate(void *args)
41421 {
41422     struct
41423     {
41424         VkDevice device;
41425         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
41426         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
41427         const void *pData;
41428     } *params = args;
41429
41430     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
41431
41432     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplate(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
41433     return STATUS_SUCCESS;
41434 }
41435
41436 #endif /* USE_STRUCT_CONVERSION */
41437
41438 #if !defined(USE_STRUCT_CONVERSION)
41439
41440 static NTSTATUS thunk64_vkUpdateDescriptorSetWithTemplateKHR(void *args)
41441 {
41442     struct vkUpdateDescriptorSetWithTemplateKHR_params *params = args;
41443
41444     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
41445
41446     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplateKHR(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
41447     return STATUS_SUCCESS;
41448 }
41449
41450 #else /* USE_STRUCT_CONVERSION */
41451
41452 static NTSTATUS thunk32_vkUpdateDescriptorSetWithTemplateKHR(void *args)
41453 {
41454     struct
41455     {
41456         VkDevice device;
41457         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
41458         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
41459         const void *pData;
41460     } *params = args;
41461
41462     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
41463
41464     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplateKHR(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
41465     return STATUS_SUCCESS;
41466 }
41467
41468 #endif /* USE_STRUCT_CONVERSION */
41469
41470 #if !defined(USE_STRUCT_CONVERSION)
41471
41472 static NTSTATUS thunk64_vkUpdateDescriptorSets(void *args)
41473 {
41474     struct vkUpdateDescriptorSets_params *params = args;
41475
41476     TRACE("%p, %u, %p, %u, %p\n", params->device, params->descriptorWriteCount, params->pDescriptorWrites, params->descriptorCopyCount, params->pDescriptorCopies);
41477
41478     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorWriteCount, params->pDescriptorWrites, params->descriptorCopyCount, params->pDescriptorCopies);
41479     return STATUS_SUCCESS;
41480 }
41481
41482 #else /* USE_STRUCT_CONVERSION */
41483
41484 static NTSTATUS thunk32_vkUpdateDescriptorSets(void *args)
41485 {
41486     struct
41487     {
41488         VkDevice device;
41489         uint32_t descriptorWriteCount;
41490         const VkWriteDescriptorSet32 *pDescriptorWrites;
41491         uint32_t descriptorCopyCount;
41492         const VkCopyDescriptorSet32 *pDescriptorCopies;
41493     } *params = args;
41494     const VkWriteDescriptorSet *pDescriptorWrites_host;
41495     const VkCopyDescriptorSet *pDescriptorCopies_host;
41496     struct conversion_context ctx;
41497
41498     TRACE("%p, %u, %p, %u, %p\n", params->device, params->descriptorWriteCount, params->pDescriptorWrites, params->descriptorCopyCount, params->pDescriptorCopies);
41499
41500     init_conversion_context(&ctx);
41501     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win32_to_host(&ctx, params->pDescriptorWrites, params->descriptorWriteCount);
41502     pDescriptorCopies_host = convert_VkCopyDescriptorSet_array_win32_to_host(&ctx, params->pDescriptorCopies, params->descriptorCopyCount);
41503     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorWriteCount, pDescriptorWrites_host, params->descriptorCopyCount, pDescriptorCopies_host);
41504     free_conversion_context(&ctx);
41505     return STATUS_SUCCESS;
41506 }
41507
41508 #endif /* USE_STRUCT_CONVERSION */
41509
41510 #if !defined(USE_STRUCT_CONVERSION)
41511
41512 static NTSTATUS thunk64_vkWaitForFences(void *args)
41513 {
41514     struct vkWaitForFences_params *params = args;
41515
41516     TRACE("%p, %u, %p, %u, 0x%s\n", params->device, params->fenceCount, params->pFences, params->waitAll, wine_dbgstr_longlong(params->timeout));
41517
41518     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitForFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences, params->waitAll, params->timeout);
41519     return STATUS_SUCCESS;
41520 }
41521
41522 #else /* USE_STRUCT_CONVERSION */
41523
41524 static NTSTATUS thunk32_vkWaitForFences(void *args)
41525 {
41526     struct
41527     {
41528         VkDevice device;
41529         uint32_t fenceCount;
41530         const VkFence *pFences;
41531         VkBool32 waitAll;
41532         uint64_t DECLSPEC_ALIGN(8) timeout;
41533         VkResult result;
41534     } *params = args;
41535
41536     TRACE("%p, %u, %p, %u, 0x%s\n", params->device, params->fenceCount, params->pFences, params->waitAll, wine_dbgstr_longlong(params->timeout));
41537
41538     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitForFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences, params->waitAll, params->timeout);
41539     return STATUS_SUCCESS;
41540 }
41541
41542 #endif /* USE_STRUCT_CONVERSION */
41543
41544 #if !defined(USE_STRUCT_CONVERSION)
41545
41546 static NTSTATUS thunk64_vkWaitForPresentKHR(void *args)
41547 {
41548     struct vkWaitForPresentKHR_params *params = args;
41549
41550     TRACE("%p, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->swapchain), wine_dbgstr_longlong(params->presentId), wine_dbgstr_longlong(params->timeout));
41551
41552     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitForPresentKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->presentId, params->timeout);
41553     return STATUS_SUCCESS;
41554 }
41555
41556 #else /* USE_STRUCT_CONVERSION */
41557
41558 static NTSTATUS thunk32_vkWaitForPresentKHR(void *args)
41559 {
41560     struct
41561     {
41562         VkDevice device;
41563         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
41564         uint64_t DECLSPEC_ALIGN(8) presentId;
41565         uint64_t DECLSPEC_ALIGN(8) timeout;
41566         VkResult result;
41567     } *params = args;
41568
41569     TRACE("%p, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->swapchain), wine_dbgstr_longlong(params->presentId), wine_dbgstr_longlong(params->timeout));
41570
41571     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitForPresentKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->presentId, params->timeout);
41572     return STATUS_SUCCESS;
41573 }
41574
41575 #endif /* USE_STRUCT_CONVERSION */
41576
41577 #if !defined(USE_STRUCT_CONVERSION)
41578
41579 static NTSTATUS thunk64_vkWaitSemaphores(void *args)
41580 {
41581     struct vkWaitSemaphores_params *params = args;
41582
41583     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
41584
41585     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphores(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
41586     return STATUS_SUCCESS;
41587 }
41588
41589 #else /* USE_STRUCT_CONVERSION */
41590
41591 static NTSTATUS thunk32_vkWaitSemaphores(void *args)
41592 {
41593     struct
41594     {
41595         VkDevice device;
41596         const VkSemaphoreWaitInfo32 *pWaitInfo;
41597         uint64_t DECLSPEC_ALIGN(8) timeout;
41598         VkResult result;
41599     } *params = args;
41600     VkSemaphoreWaitInfo pWaitInfo_host;
41601
41602     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
41603
41604     convert_VkSemaphoreWaitInfo_win32_to_host(params->pWaitInfo, &pWaitInfo_host);
41605     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphores(wine_device_from_handle(params->device)->device, &pWaitInfo_host, params->timeout);
41606     return STATUS_SUCCESS;
41607 }
41608
41609 #endif /* USE_STRUCT_CONVERSION */
41610
41611 #if !defined(USE_STRUCT_CONVERSION)
41612
41613 static NTSTATUS thunk64_vkWaitSemaphoresKHR(void *args)
41614 {
41615     struct vkWaitSemaphoresKHR_params *params = args;
41616
41617     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
41618
41619     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphoresKHR(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
41620     return STATUS_SUCCESS;
41621 }
41622
41623 #else /* USE_STRUCT_CONVERSION */
41624
41625 static NTSTATUS thunk32_vkWaitSemaphoresKHR(void *args)
41626 {
41627     struct
41628     {
41629         VkDevice device;
41630         const VkSemaphoreWaitInfo32 *pWaitInfo;
41631         uint64_t DECLSPEC_ALIGN(8) timeout;
41632         VkResult result;
41633     } *params = args;
41634     VkSemaphoreWaitInfo pWaitInfo_host;
41635
41636     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
41637
41638     convert_VkSemaphoreWaitInfo_win32_to_host(params->pWaitInfo, &pWaitInfo_host);
41639     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphoresKHR(wine_device_from_handle(params->device)->device, &pWaitInfo_host, params->timeout);
41640     return STATUS_SUCCESS;
41641 }
41642
41643 #endif /* USE_STRUCT_CONVERSION */
41644
41645 #if !defined(USE_STRUCT_CONVERSION)
41646
41647 static NTSTATUS thunk64_vkWriteAccelerationStructuresPropertiesKHR(void *args)
41648 {
41649     struct vkWriteAccelerationStructuresPropertiesKHR_params *params = args;
41650
41651     TRACE("%p, %u, %p, %#x, 0x%s, %p, 0x%s\n", params->device, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride));
41652
41653     params->result = wine_device_from_handle(params->device)->funcs.p_vkWriteAccelerationStructuresPropertiesKHR(wine_device_from_handle(params->device)->device, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, params->dataSize, params->pData, params->stride);
41654     return STATUS_SUCCESS;
41655 }
41656
41657 #else /* USE_STRUCT_CONVERSION */
41658
41659 static NTSTATUS thunk32_vkWriteAccelerationStructuresPropertiesKHR(void *args)
41660 {
41661     struct
41662     {
41663         VkDevice device;
41664         uint32_t accelerationStructureCount;
41665         const VkAccelerationStructureKHR *pAccelerationStructures;
41666         VkQueryType queryType;
41667         size_t dataSize;
41668         void *pData;
41669         size_t stride;
41670         VkResult result;
41671     } *params = args;
41672
41673     TRACE("%p, %u, %p, %#x, 0x%s, %p, 0x%s\n", params->device, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride));
41674
41675     params->result = wine_device_from_handle(params->device)->funcs.p_vkWriteAccelerationStructuresPropertiesKHR(wine_device_from_handle(params->device)->device, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, params->dataSize, params->pData, params->stride);
41676     return STATUS_SUCCESS;
41677 }
41678
41679 #endif /* USE_STRUCT_CONVERSION */
41680
41681 #if !defined(USE_STRUCT_CONVERSION)
41682
41683 static NTSTATUS thunk64_vkWriteMicromapsPropertiesEXT(void *args)
41684 {
41685     struct vkWriteMicromapsPropertiesEXT_params *params = args;
41686
41687     TRACE("%p, %u, %p, %#x, 0x%s, %p, 0x%s\n", params->device, params->micromapCount, params->pMicromaps, params->queryType, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride));
41688
41689     params->result = wine_device_from_handle(params->device)->funcs.p_vkWriteMicromapsPropertiesEXT(wine_device_from_handle(params->device)->device, params->micromapCount, params->pMicromaps, params->queryType, params->dataSize, params->pData, params->stride);
41690     return STATUS_SUCCESS;
41691 }
41692
41693 #else /* USE_STRUCT_CONVERSION */
41694
41695 static NTSTATUS thunk32_vkWriteMicromapsPropertiesEXT(void *args)
41696 {
41697     struct
41698     {
41699         VkDevice device;
41700         uint32_t micromapCount;
41701         const VkMicromapEXT *pMicromaps;
41702         VkQueryType queryType;
41703         size_t dataSize;
41704         void *pData;
41705         size_t stride;
41706         VkResult result;
41707     } *params = args;
41708
41709     TRACE("%p, %u, %p, %#x, 0x%s, %p, 0x%s\n", params->device, params->micromapCount, params->pMicromaps, params->queryType, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride));
41710
41711     params->result = wine_device_from_handle(params->device)->funcs.p_vkWriteMicromapsPropertiesEXT(wine_device_from_handle(params->device)->device, params->micromapCount, params->pMicromaps, params->queryType, params->dataSize, params->pData, params->stride);
41712     return STATUS_SUCCESS;
41713 }
41714
41715 #endif /* USE_STRUCT_CONVERSION */
41716
41717 static const char * const vk_device_extensions[] =
41718 {
41719     "VK_AMD_buffer_marker",
41720     "VK_AMD_device_coherent_memory",
41721     "VK_AMD_draw_indirect_count",
41722     "VK_AMD_gcn_shader",
41723     "VK_AMD_gpu_shader_half_float",
41724     "VK_AMD_gpu_shader_int16",
41725     "VK_AMD_memory_overallocation_behavior",
41726     "VK_AMD_mixed_attachment_samples",
41727     "VK_AMD_negative_viewport_height",
41728     "VK_AMD_pipeline_compiler_control",
41729     "VK_AMD_rasterization_order",
41730     "VK_AMD_shader_ballot",
41731     "VK_AMD_shader_core_properties",
41732     "VK_AMD_shader_core_properties2",
41733     "VK_AMD_shader_early_and_late_fragment_tests",
41734     "VK_AMD_shader_explicit_vertex_parameter",
41735     "VK_AMD_shader_fragment_mask",
41736     "VK_AMD_shader_image_load_store_lod",
41737     "VK_AMD_shader_info",
41738     "VK_AMD_shader_trinary_minmax",
41739     "VK_AMD_texture_gather_bias_lod",
41740     "VK_ARM_rasterization_order_attachment_access",
41741     "VK_ARM_shader_core_builtins",
41742     "VK_EXT_4444_formats",
41743     "VK_EXT_astc_decode_mode",
41744     "VK_EXT_attachment_feedback_loop_layout",
41745     "VK_EXT_blend_operation_advanced",
41746     "VK_EXT_border_color_swizzle",
41747     "VK_EXT_buffer_device_address",
41748     "VK_EXT_calibrated_timestamps",
41749     "VK_EXT_color_write_enable",
41750     "VK_EXT_conditional_rendering",
41751     "VK_EXT_conservative_rasterization",
41752     "VK_EXT_custom_border_color",
41753     "VK_EXT_debug_marker",
41754     "VK_EXT_depth_clamp_zero_one",
41755     "VK_EXT_depth_clip_control",
41756     "VK_EXT_depth_clip_enable",
41757     "VK_EXT_depth_range_unrestricted",
41758     "VK_EXT_descriptor_indexing",
41759     "VK_EXT_device_address_binding_report",
41760     "VK_EXT_device_fault",
41761     "VK_EXT_discard_rectangles",
41762     "VK_EXT_extended_dynamic_state",
41763     "VK_EXT_extended_dynamic_state2",
41764     "VK_EXT_extended_dynamic_state3",
41765     "VK_EXT_external_memory_host",
41766     "VK_EXT_filter_cubic",
41767     "VK_EXT_fragment_density_map",
41768     "VK_EXT_fragment_density_map2",
41769     "VK_EXT_fragment_shader_interlock",
41770     "VK_EXT_global_priority",
41771     "VK_EXT_global_priority_query",
41772     "VK_EXT_graphics_pipeline_library",
41773     "VK_EXT_host_query_reset",
41774     "VK_EXT_image_2d_view_of_3d",
41775     "VK_EXT_image_compression_control",
41776     "VK_EXT_image_compression_control_swapchain",
41777     "VK_EXT_image_robustness",
41778     "VK_EXT_image_view_min_lod",
41779     "VK_EXT_index_type_uint8",
41780     "VK_EXT_inline_uniform_block",
41781     "VK_EXT_legacy_dithering",
41782     "VK_EXT_line_rasterization",
41783     "VK_EXT_load_store_op_none",
41784     "VK_EXT_memory_budget",
41785     "VK_EXT_memory_priority",
41786     "VK_EXT_mesh_shader",
41787     "VK_EXT_multi_draw",
41788     "VK_EXT_multisampled_render_to_single_sampled",
41789     "VK_EXT_mutable_descriptor_type",
41790     "VK_EXT_non_seamless_cube_map",
41791     "VK_EXT_opacity_micromap",
41792     "VK_EXT_pageable_device_local_memory",
41793     "VK_EXT_pci_bus_info",
41794     "VK_EXT_pipeline_creation_cache_control",
41795     "VK_EXT_pipeline_creation_feedback",
41796     "VK_EXT_pipeline_properties",
41797     "VK_EXT_pipeline_protected_access",
41798     "VK_EXT_pipeline_robustness",
41799     "VK_EXT_post_depth_coverage",
41800     "VK_EXT_primitive_topology_list_restart",
41801     "VK_EXT_primitives_generated_query",
41802     "VK_EXT_private_data",
41803     "VK_EXT_provoking_vertex",
41804     "VK_EXT_queue_family_foreign",
41805     "VK_EXT_rasterization_order_attachment_access",
41806     "VK_EXT_rgba10x6_formats",
41807     "VK_EXT_robustness2",
41808     "VK_EXT_sample_locations",
41809     "VK_EXT_sampler_filter_minmax",
41810     "VK_EXT_scalar_block_layout",
41811     "VK_EXT_separate_stencil_usage",
41812     "VK_EXT_shader_atomic_float",
41813     "VK_EXT_shader_atomic_float2",
41814     "VK_EXT_shader_demote_to_helper_invocation",
41815     "VK_EXT_shader_image_atomic_int64",
41816     "VK_EXT_shader_module_identifier",
41817     "VK_EXT_shader_stencil_export",
41818     "VK_EXT_shader_subgroup_ballot",
41819     "VK_EXT_shader_subgroup_vote",
41820     "VK_EXT_shader_viewport_index_layer",
41821     "VK_EXT_subgroup_size_control",
41822     "VK_EXT_subpass_merge_feedback",
41823     "VK_EXT_texel_buffer_alignment",
41824     "VK_EXT_texture_compression_astc_hdr",
41825     "VK_EXT_tooling_info",
41826     "VK_EXT_transform_feedback",
41827     "VK_EXT_validation_cache",
41828     "VK_EXT_vertex_attribute_divisor",
41829     "VK_EXT_vertex_input_dynamic_state",
41830     "VK_EXT_ycbcr_2plane_444_formats",
41831     "VK_EXT_ycbcr_image_arrays",
41832     "VK_GOOGLE_decorate_string",
41833     "VK_GOOGLE_hlsl_functionality1",
41834     "VK_GOOGLE_user_type",
41835     "VK_HUAWEI_invocation_mask",
41836     "VK_HUAWEI_subpass_shading",
41837     "VK_IMG_filter_cubic",
41838     "VK_IMG_format_pvrtc",
41839     "VK_INTEL_performance_query",
41840     "VK_INTEL_shader_integer_functions2",
41841     "VK_KHR_16bit_storage",
41842     "VK_KHR_8bit_storage",
41843     "VK_KHR_acceleration_structure",
41844     "VK_KHR_bind_memory2",
41845     "VK_KHR_buffer_device_address",
41846     "VK_KHR_copy_commands2",
41847     "VK_KHR_create_renderpass2",
41848     "VK_KHR_dedicated_allocation",
41849     "VK_KHR_deferred_host_operations",
41850     "VK_KHR_depth_stencil_resolve",
41851     "VK_KHR_descriptor_update_template",
41852     "VK_KHR_device_group",
41853     "VK_KHR_draw_indirect_count",
41854     "VK_KHR_driver_properties",
41855     "VK_KHR_dynamic_rendering",
41856     "VK_KHR_external_fence",
41857     "VK_KHR_external_memory",
41858     "VK_KHR_external_semaphore",
41859     "VK_KHR_format_feature_flags2",
41860     "VK_KHR_fragment_shader_barycentric",
41861     "VK_KHR_fragment_shading_rate",
41862     "VK_KHR_get_memory_requirements2",
41863     "VK_KHR_global_priority",
41864     "VK_KHR_image_format_list",
41865     "VK_KHR_imageless_framebuffer",
41866     "VK_KHR_incremental_present",
41867     "VK_KHR_maintenance1",
41868     "VK_KHR_maintenance2",
41869     "VK_KHR_maintenance3",
41870     "VK_KHR_maintenance4",
41871     "VK_KHR_multiview",
41872     "VK_KHR_performance_query",
41873     "VK_KHR_pipeline_executable_properties",
41874     "VK_KHR_pipeline_library",
41875     "VK_KHR_present_id",
41876     "VK_KHR_present_wait",
41877     "VK_KHR_push_descriptor",
41878     "VK_KHR_ray_query",
41879     "VK_KHR_ray_tracing_maintenance1",
41880     "VK_KHR_ray_tracing_pipeline",
41881     "VK_KHR_relaxed_block_layout",
41882     "VK_KHR_sampler_mirror_clamp_to_edge",
41883     "VK_KHR_sampler_ycbcr_conversion",
41884     "VK_KHR_separate_depth_stencil_layouts",
41885     "VK_KHR_shader_atomic_int64",
41886     "VK_KHR_shader_clock",
41887     "VK_KHR_shader_draw_parameters",
41888     "VK_KHR_shader_float16_int8",
41889     "VK_KHR_shader_float_controls",
41890     "VK_KHR_shader_integer_dot_product",
41891     "VK_KHR_shader_non_semantic_info",
41892     "VK_KHR_shader_subgroup_extended_types",
41893     "VK_KHR_shader_subgroup_uniform_control_flow",
41894     "VK_KHR_shader_terminate_invocation",
41895     "VK_KHR_spirv_1_4",
41896     "VK_KHR_storage_buffer_storage_class",
41897     "VK_KHR_swapchain",
41898     "VK_KHR_swapchain_mutable_format",
41899     "VK_KHR_synchronization2",
41900     "VK_KHR_timeline_semaphore",
41901     "VK_KHR_uniform_buffer_standard_layout",
41902     "VK_KHR_variable_pointers",
41903     "VK_KHR_vulkan_memory_model",
41904     "VK_KHR_workgroup_memory_explicit_layout",
41905     "VK_KHR_zero_initialize_workgroup_memory",
41906     "VK_NVX_binary_import",
41907     "VK_NVX_image_view_handle",
41908     "VK_NV_clip_space_w_scaling",
41909     "VK_NV_compute_shader_derivatives",
41910     "VK_NV_cooperative_matrix",
41911     "VK_NV_copy_memory_indirect",
41912     "VK_NV_corner_sampled_image",
41913     "VK_NV_coverage_reduction_mode",
41914     "VK_NV_dedicated_allocation",
41915     "VK_NV_dedicated_allocation_image_aliasing",
41916     "VK_NV_device_diagnostic_checkpoints",
41917     "VK_NV_device_diagnostics_config",
41918     "VK_NV_device_generated_commands",
41919     "VK_NV_fill_rectangle",
41920     "VK_NV_fragment_coverage_to_color",
41921     "VK_NV_fragment_shader_barycentric",
41922     "VK_NV_fragment_shading_rate_enums",
41923     "VK_NV_framebuffer_mixed_samples",
41924     "VK_NV_geometry_shader_passthrough",
41925     "VK_NV_glsl_shader",
41926     "VK_NV_inherited_viewport_scissor",
41927     "VK_NV_linear_color_attachment",
41928     "VK_NV_memory_decompression",
41929     "VK_NV_mesh_shader",
41930     "VK_NV_optical_flow",
41931     "VK_NV_present_barrier",
41932     "VK_NV_ray_tracing",
41933     "VK_NV_ray_tracing_invocation_reorder",
41934     "VK_NV_ray_tracing_motion_blur",
41935     "VK_NV_representative_fragment_test",
41936     "VK_NV_sample_mask_override_coverage",
41937     "VK_NV_scissor_exclusive",
41938     "VK_NV_shader_image_footprint",
41939     "VK_NV_shader_sm_builtins",
41940     "VK_NV_shader_subgroup_partitioned",
41941     "VK_NV_shading_rate_image",
41942     "VK_NV_viewport_array2",
41943     "VK_NV_viewport_swizzle",
41944     "VK_QCOM_fragment_density_map_offset",
41945     "VK_QCOM_image_processing",
41946     "VK_QCOM_render_pass_shader_resolve",
41947     "VK_QCOM_render_pass_store_ops",
41948     "VK_QCOM_render_pass_transform",
41949     "VK_QCOM_rotated_copy_commands",
41950     "VK_QCOM_tile_properties",
41951     "VK_VALVE_descriptor_set_host_mapping",
41952     "VK_VALVE_mutable_descriptor_type",
41953 };
41954
41955 static const char * const vk_instance_extensions[] =
41956 {
41957     "VK_EXT_debug_report",
41958     "VK_EXT_debug_utils",
41959     "VK_EXT_swapchain_colorspace",
41960     "VK_EXT_validation_features",
41961     "VK_EXT_validation_flags",
41962     "VK_KHR_device_group_creation",
41963     "VK_KHR_external_fence_capabilities",
41964     "VK_KHR_external_memory_capabilities",
41965     "VK_KHR_external_semaphore_capabilities",
41966     "VK_KHR_get_physical_device_properties2",
41967     "VK_KHR_get_surface_capabilities2",
41968     "VK_KHR_portability_enumeration",
41969     "VK_KHR_surface",
41970     "VK_KHR_win32_surface",
41971 };
41972
41973 BOOL wine_vk_device_extension_supported(const char *name)
41974 {
41975     unsigned int i;
41976     for (i = 0; i < ARRAY_SIZE(vk_device_extensions); i++)
41977     {
41978         if (strcmp(vk_device_extensions[i], name) == 0)
41979             return TRUE;
41980     }
41981     return FALSE;
41982 }
41983
41984 BOOL wine_vk_instance_extension_supported(const char *name)
41985 {
41986     unsigned int i;
41987     for (i = 0; i < ARRAY_SIZE(vk_instance_extensions); i++)
41988     {
41989         if (strcmp(vk_instance_extensions[i], name) == 0)
41990             return TRUE;
41991     }
41992     return FALSE;
41993 }
41994
41995 BOOL wine_vk_is_type_wrapped(VkObjectType type)
41996 {
41997     return FALSE ||
41998         type == VK_OBJECT_TYPE_COMMAND_BUFFER ||
41999         type == VK_OBJECT_TYPE_COMMAND_POOL ||
42000         type == VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT ||
42001         type == VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT ||
42002         type == VK_OBJECT_TYPE_DEVICE ||
42003         type == VK_OBJECT_TYPE_INSTANCE ||
42004         type == VK_OBJECT_TYPE_PHYSICAL_DEVICE ||
42005         type == VK_OBJECT_TYPE_QUEUE ||
42006         type == VK_OBJECT_TYPE_SURFACE_KHR;
42007 }
42008
42009 #if !defined(USE_STRUCT_CONVERSION)
42010
42011 const unixlib_entry_t __wine_unix_call_funcs[] =
42012 {
42013     init_vulkan,
42014     vk_is_available_instance_function,
42015     vk_is_available_device_function,
42016     thunk64_vkAcquireNextImage2KHR,
42017     thunk64_vkAcquireNextImageKHR,
42018     thunk64_vkAcquirePerformanceConfigurationINTEL,
42019     thunk64_vkAcquireProfilingLockKHR,
42020     thunk64_vkAllocateCommandBuffers,
42021     thunk64_vkAllocateDescriptorSets,
42022     thunk64_vkAllocateMemory,
42023     thunk64_vkBeginCommandBuffer,
42024     thunk64_vkBindAccelerationStructureMemoryNV,
42025     thunk64_vkBindBufferMemory,
42026     thunk64_vkBindBufferMemory2,
42027     thunk64_vkBindBufferMemory2KHR,
42028     thunk64_vkBindImageMemory,
42029     thunk64_vkBindImageMemory2,
42030     thunk64_vkBindImageMemory2KHR,
42031     thunk64_vkBindOpticalFlowSessionImageNV,
42032     thunk64_vkBuildAccelerationStructuresKHR,
42033     thunk64_vkBuildMicromapsEXT,
42034     thunk64_vkCmdBeginConditionalRenderingEXT,
42035     thunk64_vkCmdBeginDebugUtilsLabelEXT,
42036     thunk64_vkCmdBeginQuery,
42037     thunk64_vkCmdBeginQueryIndexedEXT,
42038     thunk64_vkCmdBeginRenderPass,
42039     thunk64_vkCmdBeginRenderPass2,
42040     thunk64_vkCmdBeginRenderPass2KHR,
42041     thunk64_vkCmdBeginRendering,
42042     thunk64_vkCmdBeginRenderingKHR,
42043     thunk64_vkCmdBeginTransformFeedbackEXT,
42044     thunk64_vkCmdBindDescriptorSets,
42045     thunk64_vkCmdBindIndexBuffer,
42046     thunk64_vkCmdBindInvocationMaskHUAWEI,
42047     thunk64_vkCmdBindPipeline,
42048     thunk64_vkCmdBindPipelineShaderGroupNV,
42049     thunk64_vkCmdBindShadingRateImageNV,
42050     thunk64_vkCmdBindTransformFeedbackBuffersEXT,
42051     thunk64_vkCmdBindVertexBuffers,
42052     thunk64_vkCmdBindVertexBuffers2,
42053     thunk64_vkCmdBindVertexBuffers2EXT,
42054     thunk64_vkCmdBlitImage,
42055     thunk64_vkCmdBlitImage2,
42056     thunk64_vkCmdBlitImage2KHR,
42057     thunk64_vkCmdBuildAccelerationStructureNV,
42058     thunk64_vkCmdBuildAccelerationStructuresIndirectKHR,
42059     thunk64_vkCmdBuildAccelerationStructuresKHR,
42060     thunk64_vkCmdBuildMicromapsEXT,
42061     thunk64_vkCmdClearAttachments,
42062     thunk64_vkCmdClearColorImage,
42063     thunk64_vkCmdClearDepthStencilImage,
42064     thunk64_vkCmdCopyAccelerationStructureKHR,
42065     thunk64_vkCmdCopyAccelerationStructureNV,
42066     thunk64_vkCmdCopyAccelerationStructureToMemoryKHR,
42067     thunk64_vkCmdCopyBuffer,
42068     thunk64_vkCmdCopyBuffer2,
42069     thunk64_vkCmdCopyBuffer2KHR,
42070     thunk64_vkCmdCopyBufferToImage,
42071     thunk64_vkCmdCopyBufferToImage2,
42072     thunk64_vkCmdCopyBufferToImage2KHR,
42073     thunk64_vkCmdCopyImage,
42074     thunk64_vkCmdCopyImage2,
42075     thunk64_vkCmdCopyImage2KHR,
42076     thunk64_vkCmdCopyImageToBuffer,
42077     thunk64_vkCmdCopyImageToBuffer2,
42078     thunk64_vkCmdCopyImageToBuffer2KHR,
42079     thunk64_vkCmdCopyMemoryIndirectNV,
42080     thunk64_vkCmdCopyMemoryToAccelerationStructureKHR,
42081     thunk64_vkCmdCopyMemoryToImageIndirectNV,
42082     thunk64_vkCmdCopyMemoryToMicromapEXT,
42083     thunk64_vkCmdCopyMicromapEXT,
42084     thunk64_vkCmdCopyMicromapToMemoryEXT,
42085     thunk64_vkCmdCopyQueryPoolResults,
42086     thunk64_vkCmdCuLaunchKernelNVX,
42087     thunk64_vkCmdDebugMarkerBeginEXT,
42088     thunk64_vkCmdDebugMarkerEndEXT,
42089     thunk64_vkCmdDebugMarkerInsertEXT,
42090     thunk64_vkCmdDecompressMemoryIndirectCountNV,
42091     thunk64_vkCmdDecompressMemoryNV,
42092     thunk64_vkCmdDispatch,
42093     thunk64_vkCmdDispatchBase,
42094     thunk64_vkCmdDispatchBaseKHR,
42095     thunk64_vkCmdDispatchIndirect,
42096     thunk64_vkCmdDraw,
42097     thunk64_vkCmdDrawIndexed,
42098     thunk64_vkCmdDrawIndexedIndirect,
42099     thunk64_vkCmdDrawIndexedIndirectCount,
42100     thunk64_vkCmdDrawIndexedIndirectCountAMD,
42101     thunk64_vkCmdDrawIndexedIndirectCountKHR,
42102     thunk64_vkCmdDrawIndirect,
42103     thunk64_vkCmdDrawIndirectByteCountEXT,
42104     thunk64_vkCmdDrawIndirectCount,
42105     thunk64_vkCmdDrawIndirectCountAMD,
42106     thunk64_vkCmdDrawIndirectCountKHR,
42107     thunk64_vkCmdDrawMeshTasksEXT,
42108     thunk64_vkCmdDrawMeshTasksIndirectCountEXT,
42109     thunk64_vkCmdDrawMeshTasksIndirectCountNV,
42110     thunk64_vkCmdDrawMeshTasksIndirectEXT,
42111     thunk64_vkCmdDrawMeshTasksIndirectNV,
42112     thunk64_vkCmdDrawMeshTasksNV,
42113     thunk64_vkCmdDrawMultiEXT,
42114     thunk64_vkCmdDrawMultiIndexedEXT,
42115     thunk64_vkCmdEndConditionalRenderingEXT,
42116     thunk64_vkCmdEndDebugUtilsLabelEXT,
42117     thunk64_vkCmdEndQuery,
42118     thunk64_vkCmdEndQueryIndexedEXT,
42119     thunk64_vkCmdEndRenderPass,
42120     thunk64_vkCmdEndRenderPass2,
42121     thunk64_vkCmdEndRenderPass2KHR,
42122     thunk64_vkCmdEndRendering,
42123     thunk64_vkCmdEndRenderingKHR,
42124     thunk64_vkCmdEndTransformFeedbackEXT,
42125     thunk64_vkCmdExecuteCommands,
42126     thunk64_vkCmdExecuteGeneratedCommandsNV,
42127     thunk64_vkCmdFillBuffer,
42128     thunk64_vkCmdInsertDebugUtilsLabelEXT,
42129     thunk64_vkCmdNextSubpass,
42130     thunk64_vkCmdNextSubpass2,
42131     thunk64_vkCmdNextSubpass2KHR,
42132     thunk64_vkCmdOpticalFlowExecuteNV,
42133     thunk64_vkCmdPipelineBarrier,
42134     thunk64_vkCmdPipelineBarrier2,
42135     thunk64_vkCmdPipelineBarrier2KHR,
42136     thunk64_vkCmdPreprocessGeneratedCommandsNV,
42137     thunk64_vkCmdPushConstants,
42138     thunk64_vkCmdPushDescriptorSetKHR,
42139     thunk64_vkCmdPushDescriptorSetWithTemplateKHR,
42140     thunk64_vkCmdResetEvent,
42141     thunk64_vkCmdResetEvent2,
42142     thunk64_vkCmdResetEvent2KHR,
42143     thunk64_vkCmdResetQueryPool,
42144     thunk64_vkCmdResolveImage,
42145     thunk64_vkCmdResolveImage2,
42146     thunk64_vkCmdResolveImage2KHR,
42147     thunk64_vkCmdSetAlphaToCoverageEnableEXT,
42148     thunk64_vkCmdSetAlphaToOneEnableEXT,
42149     thunk64_vkCmdSetBlendConstants,
42150     thunk64_vkCmdSetCheckpointNV,
42151     thunk64_vkCmdSetCoarseSampleOrderNV,
42152     thunk64_vkCmdSetColorBlendAdvancedEXT,
42153     thunk64_vkCmdSetColorBlendEnableEXT,
42154     thunk64_vkCmdSetColorBlendEquationEXT,
42155     thunk64_vkCmdSetColorWriteEnableEXT,
42156     thunk64_vkCmdSetColorWriteMaskEXT,
42157     thunk64_vkCmdSetConservativeRasterizationModeEXT,
42158     thunk64_vkCmdSetCoverageModulationModeNV,
42159     thunk64_vkCmdSetCoverageModulationTableEnableNV,
42160     thunk64_vkCmdSetCoverageModulationTableNV,
42161     thunk64_vkCmdSetCoverageReductionModeNV,
42162     thunk64_vkCmdSetCoverageToColorEnableNV,
42163     thunk64_vkCmdSetCoverageToColorLocationNV,
42164     thunk64_vkCmdSetCullMode,
42165     thunk64_vkCmdSetCullModeEXT,
42166     thunk64_vkCmdSetDepthBias,
42167     thunk64_vkCmdSetDepthBiasEnable,
42168     thunk64_vkCmdSetDepthBiasEnableEXT,
42169     thunk64_vkCmdSetDepthBounds,
42170     thunk64_vkCmdSetDepthBoundsTestEnable,
42171     thunk64_vkCmdSetDepthBoundsTestEnableEXT,
42172     thunk64_vkCmdSetDepthClampEnableEXT,
42173     thunk64_vkCmdSetDepthClipEnableEXT,
42174     thunk64_vkCmdSetDepthClipNegativeOneToOneEXT,
42175     thunk64_vkCmdSetDepthCompareOp,
42176     thunk64_vkCmdSetDepthCompareOpEXT,
42177     thunk64_vkCmdSetDepthTestEnable,
42178     thunk64_vkCmdSetDepthTestEnableEXT,
42179     thunk64_vkCmdSetDepthWriteEnable,
42180     thunk64_vkCmdSetDepthWriteEnableEXT,
42181     thunk64_vkCmdSetDeviceMask,
42182     thunk64_vkCmdSetDeviceMaskKHR,
42183     thunk64_vkCmdSetDiscardRectangleEXT,
42184     thunk64_vkCmdSetEvent,
42185     thunk64_vkCmdSetEvent2,
42186     thunk64_vkCmdSetEvent2KHR,
42187     thunk64_vkCmdSetExclusiveScissorNV,
42188     thunk64_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
42189     thunk64_vkCmdSetFragmentShadingRateEnumNV,
42190     thunk64_vkCmdSetFragmentShadingRateKHR,
42191     thunk64_vkCmdSetFrontFace,
42192     thunk64_vkCmdSetFrontFaceEXT,
42193     thunk64_vkCmdSetLineRasterizationModeEXT,
42194     thunk64_vkCmdSetLineStippleEXT,
42195     thunk64_vkCmdSetLineStippleEnableEXT,
42196     thunk64_vkCmdSetLineWidth,
42197     thunk64_vkCmdSetLogicOpEXT,
42198     thunk64_vkCmdSetLogicOpEnableEXT,
42199     thunk64_vkCmdSetPatchControlPointsEXT,
42200     thunk64_vkCmdSetPerformanceMarkerINTEL,
42201     thunk64_vkCmdSetPerformanceOverrideINTEL,
42202     thunk64_vkCmdSetPerformanceStreamMarkerINTEL,
42203     thunk64_vkCmdSetPolygonModeEXT,
42204     thunk64_vkCmdSetPrimitiveRestartEnable,
42205     thunk64_vkCmdSetPrimitiveRestartEnableEXT,
42206     thunk64_vkCmdSetPrimitiveTopology,
42207     thunk64_vkCmdSetPrimitiveTopologyEXT,
42208     thunk64_vkCmdSetProvokingVertexModeEXT,
42209     thunk64_vkCmdSetRasterizationSamplesEXT,
42210     thunk64_vkCmdSetRasterizationStreamEXT,
42211     thunk64_vkCmdSetRasterizerDiscardEnable,
42212     thunk64_vkCmdSetRasterizerDiscardEnableEXT,
42213     thunk64_vkCmdSetRayTracingPipelineStackSizeKHR,
42214     thunk64_vkCmdSetRepresentativeFragmentTestEnableNV,
42215     thunk64_vkCmdSetSampleLocationsEXT,
42216     thunk64_vkCmdSetSampleLocationsEnableEXT,
42217     thunk64_vkCmdSetSampleMaskEXT,
42218     thunk64_vkCmdSetScissor,
42219     thunk64_vkCmdSetScissorWithCount,
42220     thunk64_vkCmdSetScissorWithCountEXT,
42221     thunk64_vkCmdSetShadingRateImageEnableNV,
42222     thunk64_vkCmdSetStencilCompareMask,
42223     thunk64_vkCmdSetStencilOp,
42224     thunk64_vkCmdSetStencilOpEXT,
42225     thunk64_vkCmdSetStencilReference,
42226     thunk64_vkCmdSetStencilTestEnable,
42227     thunk64_vkCmdSetStencilTestEnableEXT,
42228     thunk64_vkCmdSetStencilWriteMask,
42229     thunk64_vkCmdSetTessellationDomainOriginEXT,
42230     thunk64_vkCmdSetVertexInputEXT,
42231     thunk64_vkCmdSetViewport,
42232     thunk64_vkCmdSetViewportShadingRatePaletteNV,
42233     thunk64_vkCmdSetViewportSwizzleNV,
42234     thunk64_vkCmdSetViewportWScalingEnableNV,
42235     thunk64_vkCmdSetViewportWScalingNV,
42236     thunk64_vkCmdSetViewportWithCount,
42237     thunk64_vkCmdSetViewportWithCountEXT,
42238     thunk64_vkCmdSubpassShadingHUAWEI,
42239     thunk64_vkCmdTraceRaysIndirect2KHR,
42240     thunk64_vkCmdTraceRaysIndirectKHR,
42241     thunk64_vkCmdTraceRaysKHR,
42242     thunk64_vkCmdTraceRaysNV,
42243     thunk64_vkCmdUpdateBuffer,
42244     thunk64_vkCmdWaitEvents,
42245     thunk64_vkCmdWaitEvents2,
42246     thunk64_vkCmdWaitEvents2KHR,
42247     thunk64_vkCmdWriteAccelerationStructuresPropertiesKHR,
42248     thunk64_vkCmdWriteAccelerationStructuresPropertiesNV,
42249     thunk64_vkCmdWriteBufferMarker2AMD,
42250     thunk64_vkCmdWriteBufferMarkerAMD,
42251     thunk64_vkCmdWriteMicromapsPropertiesEXT,
42252     thunk64_vkCmdWriteTimestamp,
42253     thunk64_vkCmdWriteTimestamp2,
42254     thunk64_vkCmdWriteTimestamp2KHR,
42255     thunk64_vkCompileDeferredNV,
42256     thunk64_vkCopyAccelerationStructureKHR,
42257     thunk64_vkCopyAccelerationStructureToMemoryKHR,
42258     thunk64_vkCopyMemoryToAccelerationStructureKHR,
42259     thunk64_vkCopyMemoryToMicromapEXT,
42260     thunk64_vkCopyMicromapEXT,
42261     thunk64_vkCopyMicromapToMemoryEXT,
42262     thunk64_vkCreateAccelerationStructureKHR,
42263     thunk64_vkCreateAccelerationStructureNV,
42264     thunk64_vkCreateBuffer,
42265     thunk64_vkCreateBufferView,
42266     thunk64_vkCreateCommandPool,
42267     thunk64_vkCreateComputePipelines,
42268     thunk64_vkCreateCuFunctionNVX,
42269     thunk64_vkCreateCuModuleNVX,
42270     thunk64_vkCreateDebugReportCallbackEXT,
42271     thunk64_vkCreateDebugUtilsMessengerEXT,
42272     thunk64_vkCreateDeferredOperationKHR,
42273     thunk64_vkCreateDescriptorPool,
42274     thunk64_vkCreateDescriptorSetLayout,
42275     thunk64_vkCreateDescriptorUpdateTemplate,
42276     thunk64_vkCreateDescriptorUpdateTemplateKHR,
42277     thunk64_vkCreateDevice,
42278     thunk64_vkCreateEvent,
42279     thunk64_vkCreateFence,
42280     thunk64_vkCreateFramebuffer,
42281     thunk64_vkCreateGraphicsPipelines,
42282     thunk64_vkCreateImage,
42283     thunk64_vkCreateImageView,
42284     thunk64_vkCreateIndirectCommandsLayoutNV,
42285     thunk64_vkCreateInstance,
42286     thunk64_vkCreateMicromapEXT,
42287     thunk64_vkCreateOpticalFlowSessionNV,
42288     thunk64_vkCreatePipelineCache,
42289     thunk64_vkCreatePipelineLayout,
42290     thunk64_vkCreatePrivateDataSlot,
42291     thunk64_vkCreatePrivateDataSlotEXT,
42292     thunk64_vkCreateQueryPool,
42293     thunk64_vkCreateRayTracingPipelinesKHR,
42294     thunk64_vkCreateRayTracingPipelinesNV,
42295     thunk64_vkCreateRenderPass,
42296     thunk64_vkCreateRenderPass2,
42297     thunk64_vkCreateRenderPass2KHR,
42298     thunk64_vkCreateSampler,
42299     thunk64_vkCreateSamplerYcbcrConversion,
42300     thunk64_vkCreateSamplerYcbcrConversionKHR,
42301     thunk64_vkCreateSemaphore,
42302     thunk64_vkCreateShaderModule,
42303     thunk64_vkCreateSwapchainKHR,
42304     thunk64_vkCreateValidationCacheEXT,
42305     thunk64_vkCreateWin32SurfaceKHR,
42306     thunk64_vkDebugMarkerSetObjectNameEXT,
42307     thunk64_vkDebugMarkerSetObjectTagEXT,
42308     thunk64_vkDebugReportMessageEXT,
42309     thunk64_vkDeferredOperationJoinKHR,
42310     thunk64_vkDestroyAccelerationStructureKHR,
42311     thunk64_vkDestroyAccelerationStructureNV,
42312     thunk64_vkDestroyBuffer,
42313     thunk64_vkDestroyBufferView,
42314     thunk64_vkDestroyCommandPool,
42315     thunk64_vkDestroyCuFunctionNVX,
42316     thunk64_vkDestroyCuModuleNVX,
42317     thunk64_vkDestroyDebugReportCallbackEXT,
42318     thunk64_vkDestroyDebugUtilsMessengerEXT,
42319     thunk64_vkDestroyDeferredOperationKHR,
42320     thunk64_vkDestroyDescriptorPool,
42321     thunk64_vkDestroyDescriptorSetLayout,
42322     thunk64_vkDestroyDescriptorUpdateTemplate,
42323     thunk64_vkDestroyDescriptorUpdateTemplateKHR,
42324     thunk64_vkDestroyDevice,
42325     thunk64_vkDestroyEvent,
42326     thunk64_vkDestroyFence,
42327     thunk64_vkDestroyFramebuffer,
42328     thunk64_vkDestroyImage,
42329     thunk64_vkDestroyImageView,
42330     thunk64_vkDestroyIndirectCommandsLayoutNV,
42331     thunk64_vkDestroyInstance,
42332     thunk64_vkDestroyMicromapEXT,
42333     thunk64_vkDestroyOpticalFlowSessionNV,
42334     thunk64_vkDestroyPipeline,
42335     thunk64_vkDestroyPipelineCache,
42336     thunk64_vkDestroyPipelineLayout,
42337     thunk64_vkDestroyPrivateDataSlot,
42338     thunk64_vkDestroyPrivateDataSlotEXT,
42339     thunk64_vkDestroyQueryPool,
42340     thunk64_vkDestroyRenderPass,
42341     thunk64_vkDestroySampler,
42342     thunk64_vkDestroySamplerYcbcrConversion,
42343     thunk64_vkDestroySamplerYcbcrConversionKHR,
42344     thunk64_vkDestroySemaphore,
42345     thunk64_vkDestroyShaderModule,
42346     thunk64_vkDestroySurfaceKHR,
42347     thunk64_vkDestroySwapchainKHR,
42348     thunk64_vkDestroyValidationCacheEXT,
42349     thunk64_vkDeviceWaitIdle,
42350     thunk64_vkEndCommandBuffer,
42351     thunk64_vkEnumerateDeviceExtensionProperties,
42352     thunk64_vkEnumerateDeviceLayerProperties,
42353     thunk64_vkEnumerateInstanceExtensionProperties,
42354     thunk64_vkEnumerateInstanceVersion,
42355     thunk64_vkEnumeratePhysicalDeviceGroups,
42356     thunk64_vkEnumeratePhysicalDeviceGroupsKHR,
42357     thunk64_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
42358     thunk64_vkEnumeratePhysicalDevices,
42359     thunk64_vkFlushMappedMemoryRanges,
42360     thunk64_vkFreeCommandBuffers,
42361     thunk64_vkFreeDescriptorSets,
42362     thunk64_vkFreeMemory,
42363     thunk64_vkGetAccelerationStructureBuildSizesKHR,
42364     thunk64_vkGetAccelerationStructureDeviceAddressKHR,
42365     thunk64_vkGetAccelerationStructureHandleNV,
42366     thunk64_vkGetAccelerationStructureMemoryRequirementsNV,
42367     thunk64_vkGetBufferDeviceAddress,
42368     thunk64_vkGetBufferDeviceAddressEXT,
42369     thunk64_vkGetBufferDeviceAddressKHR,
42370     thunk64_vkGetBufferMemoryRequirements,
42371     thunk64_vkGetBufferMemoryRequirements2,
42372     thunk64_vkGetBufferMemoryRequirements2KHR,
42373     thunk64_vkGetBufferOpaqueCaptureAddress,
42374     thunk64_vkGetBufferOpaqueCaptureAddressKHR,
42375     thunk64_vkGetCalibratedTimestampsEXT,
42376     thunk64_vkGetDeferredOperationMaxConcurrencyKHR,
42377     thunk64_vkGetDeferredOperationResultKHR,
42378     thunk64_vkGetDescriptorSetHostMappingVALVE,
42379     thunk64_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
42380     thunk64_vkGetDescriptorSetLayoutSupport,
42381     thunk64_vkGetDescriptorSetLayoutSupportKHR,
42382     thunk64_vkGetDeviceAccelerationStructureCompatibilityKHR,
42383     thunk64_vkGetDeviceBufferMemoryRequirements,
42384     thunk64_vkGetDeviceBufferMemoryRequirementsKHR,
42385     thunk64_vkGetDeviceFaultInfoEXT,
42386     thunk64_vkGetDeviceGroupPeerMemoryFeatures,
42387     thunk64_vkGetDeviceGroupPeerMemoryFeaturesKHR,
42388     thunk64_vkGetDeviceGroupPresentCapabilitiesKHR,
42389     thunk64_vkGetDeviceGroupSurfacePresentModesKHR,
42390     thunk64_vkGetDeviceImageMemoryRequirements,
42391     thunk64_vkGetDeviceImageMemoryRequirementsKHR,
42392     thunk64_vkGetDeviceImageSparseMemoryRequirements,
42393     thunk64_vkGetDeviceImageSparseMemoryRequirementsKHR,
42394     thunk64_vkGetDeviceMemoryCommitment,
42395     thunk64_vkGetDeviceMemoryOpaqueCaptureAddress,
42396     thunk64_vkGetDeviceMemoryOpaqueCaptureAddressKHR,
42397     thunk64_vkGetDeviceMicromapCompatibilityEXT,
42398     thunk64_vkGetDeviceQueue,
42399     thunk64_vkGetDeviceQueue2,
42400     thunk64_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
42401     thunk64_vkGetDynamicRenderingTilePropertiesQCOM,
42402     thunk64_vkGetEventStatus,
42403     thunk64_vkGetFenceStatus,
42404     thunk64_vkGetFramebufferTilePropertiesQCOM,
42405     thunk64_vkGetGeneratedCommandsMemoryRequirementsNV,
42406     thunk64_vkGetImageMemoryRequirements,
42407     thunk64_vkGetImageMemoryRequirements2,
42408     thunk64_vkGetImageMemoryRequirements2KHR,
42409     thunk64_vkGetImageSparseMemoryRequirements,
42410     thunk64_vkGetImageSparseMemoryRequirements2,
42411     thunk64_vkGetImageSparseMemoryRequirements2KHR,
42412     thunk64_vkGetImageSubresourceLayout,
42413     thunk64_vkGetImageSubresourceLayout2EXT,
42414     thunk64_vkGetImageViewAddressNVX,
42415     thunk64_vkGetImageViewHandleNVX,
42416     thunk64_vkGetMemoryHostPointerPropertiesEXT,
42417     thunk64_vkGetMicromapBuildSizesEXT,
42418     thunk64_vkGetPerformanceParameterINTEL,
42419     thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
42420     thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
42421     thunk64_vkGetPhysicalDeviceExternalBufferProperties,
42422     thunk64_vkGetPhysicalDeviceExternalBufferPropertiesKHR,
42423     thunk64_vkGetPhysicalDeviceExternalFenceProperties,
42424     thunk64_vkGetPhysicalDeviceExternalFencePropertiesKHR,
42425     thunk64_vkGetPhysicalDeviceExternalSemaphoreProperties,
42426     thunk64_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,
42427     thunk64_vkGetPhysicalDeviceFeatures,
42428     thunk64_vkGetPhysicalDeviceFeatures2,
42429     thunk64_vkGetPhysicalDeviceFeatures2KHR,
42430     thunk64_vkGetPhysicalDeviceFormatProperties,
42431     thunk64_vkGetPhysicalDeviceFormatProperties2,
42432     thunk64_vkGetPhysicalDeviceFormatProperties2KHR,
42433     thunk64_vkGetPhysicalDeviceFragmentShadingRatesKHR,
42434     thunk64_vkGetPhysicalDeviceImageFormatProperties,
42435     thunk64_vkGetPhysicalDeviceImageFormatProperties2,
42436     thunk64_vkGetPhysicalDeviceImageFormatProperties2KHR,
42437     thunk64_vkGetPhysicalDeviceMemoryProperties,
42438     thunk64_vkGetPhysicalDeviceMemoryProperties2,
42439     thunk64_vkGetPhysicalDeviceMemoryProperties2KHR,
42440     thunk64_vkGetPhysicalDeviceMultisamplePropertiesEXT,
42441     thunk64_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
42442     thunk64_vkGetPhysicalDevicePresentRectanglesKHR,
42443     thunk64_vkGetPhysicalDeviceProperties,
42444     thunk64_vkGetPhysicalDeviceProperties2,
42445     thunk64_vkGetPhysicalDeviceProperties2KHR,
42446     thunk64_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
42447     thunk64_vkGetPhysicalDeviceQueueFamilyProperties,
42448     thunk64_vkGetPhysicalDeviceQueueFamilyProperties2,
42449     thunk64_vkGetPhysicalDeviceQueueFamilyProperties2KHR,
42450     thunk64_vkGetPhysicalDeviceSparseImageFormatProperties,
42451     thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2,
42452     thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,
42453     thunk64_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
42454     thunk64_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
42455     thunk64_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
42456     thunk64_vkGetPhysicalDeviceSurfaceFormats2KHR,
42457     thunk64_vkGetPhysicalDeviceSurfaceFormatsKHR,
42458     thunk64_vkGetPhysicalDeviceSurfacePresentModesKHR,
42459     thunk64_vkGetPhysicalDeviceSurfaceSupportKHR,
42460     thunk64_vkGetPhysicalDeviceToolProperties,
42461     thunk64_vkGetPhysicalDeviceToolPropertiesEXT,
42462     thunk64_vkGetPhysicalDeviceWin32PresentationSupportKHR,
42463     thunk64_vkGetPipelineCacheData,
42464     thunk64_vkGetPipelineExecutableInternalRepresentationsKHR,
42465     thunk64_vkGetPipelineExecutablePropertiesKHR,
42466     thunk64_vkGetPipelineExecutableStatisticsKHR,
42467     thunk64_vkGetPipelinePropertiesEXT,
42468     thunk64_vkGetPrivateData,
42469     thunk64_vkGetPrivateDataEXT,
42470     thunk64_vkGetQueryPoolResults,
42471     thunk64_vkGetQueueCheckpointData2NV,
42472     thunk64_vkGetQueueCheckpointDataNV,
42473     thunk64_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
42474     thunk64_vkGetRayTracingShaderGroupHandlesKHR,
42475     thunk64_vkGetRayTracingShaderGroupHandlesNV,
42476     thunk64_vkGetRayTracingShaderGroupStackSizeKHR,
42477     thunk64_vkGetRenderAreaGranularity,
42478     thunk64_vkGetSemaphoreCounterValue,
42479     thunk64_vkGetSemaphoreCounterValueKHR,
42480     thunk64_vkGetShaderInfoAMD,
42481     thunk64_vkGetShaderModuleCreateInfoIdentifierEXT,
42482     thunk64_vkGetShaderModuleIdentifierEXT,
42483     thunk64_vkGetSwapchainImagesKHR,
42484     thunk64_vkGetValidationCacheDataEXT,
42485     thunk64_vkInitializePerformanceApiINTEL,
42486     thunk64_vkInvalidateMappedMemoryRanges,
42487     thunk64_vkMapMemory,
42488     thunk64_vkMergePipelineCaches,
42489     thunk64_vkMergeValidationCachesEXT,
42490     thunk64_vkQueueBeginDebugUtilsLabelEXT,
42491     thunk64_vkQueueBindSparse,
42492     thunk64_vkQueueEndDebugUtilsLabelEXT,
42493     thunk64_vkQueueInsertDebugUtilsLabelEXT,
42494     thunk64_vkQueuePresentKHR,
42495     thunk64_vkQueueSetPerformanceConfigurationINTEL,
42496     thunk64_vkQueueSubmit,
42497     thunk64_vkQueueSubmit2,
42498     thunk64_vkQueueSubmit2KHR,
42499     thunk64_vkQueueWaitIdle,
42500     thunk64_vkReleasePerformanceConfigurationINTEL,
42501     thunk64_vkReleaseProfilingLockKHR,
42502     thunk64_vkResetCommandBuffer,
42503     thunk64_vkResetCommandPool,
42504     thunk64_vkResetDescriptorPool,
42505     thunk64_vkResetEvent,
42506     thunk64_vkResetFences,
42507     thunk64_vkResetQueryPool,
42508     thunk64_vkResetQueryPoolEXT,
42509     thunk64_vkSetDebugUtilsObjectNameEXT,
42510     thunk64_vkSetDebugUtilsObjectTagEXT,
42511     thunk64_vkSetDeviceMemoryPriorityEXT,
42512     thunk64_vkSetEvent,
42513     thunk64_vkSetPrivateData,
42514     thunk64_vkSetPrivateDataEXT,
42515     thunk64_vkSignalSemaphore,
42516     thunk64_vkSignalSemaphoreKHR,
42517     thunk64_vkSubmitDebugUtilsMessageEXT,
42518     thunk64_vkTrimCommandPool,
42519     thunk64_vkTrimCommandPoolKHR,
42520     thunk64_vkUninitializePerformanceApiINTEL,
42521     thunk64_vkUnmapMemory,
42522     thunk64_vkUpdateDescriptorSetWithTemplate,
42523     thunk64_vkUpdateDescriptorSetWithTemplateKHR,
42524     thunk64_vkUpdateDescriptorSets,
42525     thunk64_vkWaitForFences,
42526     thunk64_vkWaitForPresentKHR,
42527     thunk64_vkWaitSemaphores,
42528     thunk64_vkWaitSemaphoresKHR,
42529     thunk64_vkWriteAccelerationStructuresPropertiesKHR,
42530     thunk64_vkWriteMicromapsPropertiesEXT,
42531 };
42532 C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);
42533
42534 #else /* USE_STRUCT_CONVERSION) */
42535
42536 const unixlib_entry_t __wine_unix_call_funcs[] =
42537 {
42538     init_vulkan,
42539     vk_is_available_instance_function,
42540     vk_is_available_device_function,
42541     thunk32_vkAcquireNextImage2KHR,
42542     thunk32_vkAcquireNextImageKHR,
42543     thunk32_vkAcquirePerformanceConfigurationINTEL,
42544     thunk32_vkAcquireProfilingLockKHR,
42545     thunk32_vkAllocateCommandBuffers,
42546     thunk32_vkAllocateDescriptorSets,
42547     thunk32_vkAllocateMemory,
42548     thunk32_vkBeginCommandBuffer,
42549     thunk32_vkBindAccelerationStructureMemoryNV,
42550     thunk32_vkBindBufferMemory,
42551     thunk32_vkBindBufferMemory2,
42552     thunk32_vkBindBufferMemory2KHR,
42553     thunk32_vkBindImageMemory,
42554     thunk32_vkBindImageMemory2,
42555     thunk32_vkBindImageMemory2KHR,
42556     thunk32_vkBindOpticalFlowSessionImageNV,
42557     thunk32_vkBuildAccelerationStructuresKHR,
42558     thunk32_vkBuildMicromapsEXT,
42559     thunk32_vkCmdBeginConditionalRenderingEXT,
42560     thunk32_vkCmdBeginDebugUtilsLabelEXT,
42561     thunk32_vkCmdBeginQuery,
42562     thunk32_vkCmdBeginQueryIndexedEXT,
42563     thunk32_vkCmdBeginRenderPass,
42564     thunk32_vkCmdBeginRenderPass2,
42565     thunk32_vkCmdBeginRenderPass2KHR,
42566     thunk32_vkCmdBeginRendering,
42567     thunk32_vkCmdBeginRenderingKHR,
42568     thunk32_vkCmdBeginTransformFeedbackEXT,
42569     thunk32_vkCmdBindDescriptorSets,
42570     thunk32_vkCmdBindIndexBuffer,
42571     thunk32_vkCmdBindInvocationMaskHUAWEI,
42572     thunk32_vkCmdBindPipeline,
42573     thunk32_vkCmdBindPipelineShaderGroupNV,
42574     thunk32_vkCmdBindShadingRateImageNV,
42575     thunk32_vkCmdBindTransformFeedbackBuffersEXT,
42576     thunk32_vkCmdBindVertexBuffers,
42577     thunk32_vkCmdBindVertexBuffers2,
42578     thunk32_vkCmdBindVertexBuffers2EXT,
42579     thunk32_vkCmdBlitImage,
42580     thunk32_vkCmdBlitImage2,
42581     thunk32_vkCmdBlitImage2KHR,
42582     thunk32_vkCmdBuildAccelerationStructureNV,
42583     thunk32_vkCmdBuildAccelerationStructuresIndirectKHR,
42584     thunk32_vkCmdBuildAccelerationStructuresKHR,
42585     thunk32_vkCmdBuildMicromapsEXT,
42586     thunk32_vkCmdClearAttachments,
42587     thunk32_vkCmdClearColorImage,
42588     thunk32_vkCmdClearDepthStencilImage,
42589     thunk32_vkCmdCopyAccelerationStructureKHR,
42590     thunk32_vkCmdCopyAccelerationStructureNV,
42591     thunk32_vkCmdCopyAccelerationStructureToMemoryKHR,
42592     thunk32_vkCmdCopyBuffer,
42593     thunk32_vkCmdCopyBuffer2,
42594     thunk32_vkCmdCopyBuffer2KHR,
42595     thunk32_vkCmdCopyBufferToImage,
42596     thunk32_vkCmdCopyBufferToImage2,
42597     thunk32_vkCmdCopyBufferToImage2KHR,
42598     thunk32_vkCmdCopyImage,
42599     thunk32_vkCmdCopyImage2,
42600     thunk32_vkCmdCopyImage2KHR,
42601     thunk32_vkCmdCopyImageToBuffer,
42602     thunk32_vkCmdCopyImageToBuffer2,
42603     thunk32_vkCmdCopyImageToBuffer2KHR,
42604     thunk32_vkCmdCopyMemoryIndirectNV,
42605     thunk32_vkCmdCopyMemoryToAccelerationStructureKHR,
42606     thunk32_vkCmdCopyMemoryToImageIndirectNV,
42607     thunk32_vkCmdCopyMemoryToMicromapEXT,
42608     thunk32_vkCmdCopyMicromapEXT,
42609     thunk32_vkCmdCopyMicromapToMemoryEXT,
42610     thunk32_vkCmdCopyQueryPoolResults,
42611     thunk32_vkCmdCuLaunchKernelNVX,
42612     thunk32_vkCmdDebugMarkerBeginEXT,
42613     thunk32_vkCmdDebugMarkerEndEXT,
42614     thunk32_vkCmdDebugMarkerInsertEXT,
42615     thunk32_vkCmdDecompressMemoryIndirectCountNV,
42616     thunk32_vkCmdDecompressMemoryNV,
42617     thunk32_vkCmdDispatch,
42618     thunk32_vkCmdDispatchBase,
42619     thunk32_vkCmdDispatchBaseKHR,
42620     thunk32_vkCmdDispatchIndirect,
42621     thunk32_vkCmdDraw,
42622     thunk32_vkCmdDrawIndexed,
42623     thunk32_vkCmdDrawIndexedIndirect,
42624     thunk32_vkCmdDrawIndexedIndirectCount,
42625     thunk32_vkCmdDrawIndexedIndirectCountAMD,
42626     thunk32_vkCmdDrawIndexedIndirectCountKHR,
42627     thunk32_vkCmdDrawIndirect,
42628     thunk32_vkCmdDrawIndirectByteCountEXT,
42629     thunk32_vkCmdDrawIndirectCount,
42630     thunk32_vkCmdDrawIndirectCountAMD,
42631     thunk32_vkCmdDrawIndirectCountKHR,
42632     thunk32_vkCmdDrawMeshTasksEXT,
42633     thunk32_vkCmdDrawMeshTasksIndirectCountEXT,
42634     thunk32_vkCmdDrawMeshTasksIndirectCountNV,
42635     thunk32_vkCmdDrawMeshTasksIndirectEXT,
42636     thunk32_vkCmdDrawMeshTasksIndirectNV,
42637     thunk32_vkCmdDrawMeshTasksNV,
42638     thunk32_vkCmdDrawMultiEXT,
42639     thunk32_vkCmdDrawMultiIndexedEXT,
42640     thunk32_vkCmdEndConditionalRenderingEXT,
42641     thunk32_vkCmdEndDebugUtilsLabelEXT,
42642     thunk32_vkCmdEndQuery,
42643     thunk32_vkCmdEndQueryIndexedEXT,
42644     thunk32_vkCmdEndRenderPass,
42645     thunk32_vkCmdEndRenderPass2,
42646     thunk32_vkCmdEndRenderPass2KHR,
42647     thunk32_vkCmdEndRendering,
42648     thunk32_vkCmdEndRenderingKHR,
42649     thunk32_vkCmdEndTransformFeedbackEXT,
42650     thunk32_vkCmdExecuteCommands,
42651     thunk32_vkCmdExecuteGeneratedCommandsNV,
42652     thunk32_vkCmdFillBuffer,
42653     thunk32_vkCmdInsertDebugUtilsLabelEXT,
42654     thunk32_vkCmdNextSubpass,
42655     thunk32_vkCmdNextSubpass2,
42656     thunk32_vkCmdNextSubpass2KHR,
42657     thunk32_vkCmdOpticalFlowExecuteNV,
42658     thunk32_vkCmdPipelineBarrier,
42659     thunk32_vkCmdPipelineBarrier2,
42660     thunk32_vkCmdPipelineBarrier2KHR,
42661     thunk32_vkCmdPreprocessGeneratedCommandsNV,
42662     thunk32_vkCmdPushConstants,
42663     thunk32_vkCmdPushDescriptorSetKHR,
42664     thunk32_vkCmdPushDescriptorSetWithTemplateKHR,
42665     thunk32_vkCmdResetEvent,
42666     thunk32_vkCmdResetEvent2,
42667     thunk32_vkCmdResetEvent2KHR,
42668     thunk32_vkCmdResetQueryPool,
42669     thunk32_vkCmdResolveImage,
42670     thunk32_vkCmdResolveImage2,
42671     thunk32_vkCmdResolveImage2KHR,
42672     thunk32_vkCmdSetAlphaToCoverageEnableEXT,
42673     thunk32_vkCmdSetAlphaToOneEnableEXT,
42674     thunk32_vkCmdSetBlendConstants,
42675     thunk32_vkCmdSetCheckpointNV,
42676     thunk32_vkCmdSetCoarseSampleOrderNV,
42677     thunk32_vkCmdSetColorBlendAdvancedEXT,
42678     thunk32_vkCmdSetColorBlendEnableEXT,
42679     thunk32_vkCmdSetColorBlendEquationEXT,
42680     thunk32_vkCmdSetColorWriteEnableEXT,
42681     thunk32_vkCmdSetColorWriteMaskEXT,
42682     thunk32_vkCmdSetConservativeRasterizationModeEXT,
42683     thunk32_vkCmdSetCoverageModulationModeNV,
42684     thunk32_vkCmdSetCoverageModulationTableEnableNV,
42685     thunk32_vkCmdSetCoverageModulationTableNV,
42686     thunk32_vkCmdSetCoverageReductionModeNV,
42687     thunk32_vkCmdSetCoverageToColorEnableNV,
42688     thunk32_vkCmdSetCoverageToColorLocationNV,
42689     thunk32_vkCmdSetCullMode,
42690     thunk32_vkCmdSetCullModeEXT,
42691     thunk32_vkCmdSetDepthBias,
42692     thunk32_vkCmdSetDepthBiasEnable,
42693     thunk32_vkCmdSetDepthBiasEnableEXT,
42694     thunk32_vkCmdSetDepthBounds,
42695     thunk32_vkCmdSetDepthBoundsTestEnable,
42696     thunk32_vkCmdSetDepthBoundsTestEnableEXT,
42697     thunk32_vkCmdSetDepthClampEnableEXT,
42698     thunk32_vkCmdSetDepthClipEnableEXT,
42699     thunk32_vkCmdSetDepthClipNegativeOneToOneEXT,
42700     thunk32_vkCmdSetDepthCompareOp,
42701     thunk32_vkCmdSetDepthCompareOpEXT,
42702     thunk32_vkCmdSetDepthTestEnable,
42703     thunk32_vkCmdSetDepthTestEnableEXT,
42704     thunk32_vkCmdSetDepthWriteEnable,
42705     thunk32_vkCmdSetDepthWriteEnableEXT,
42706     thunk32_vkCmdSetDeviceMask,
42707     thunk32_vkCmdSetDeviceMaskKHR,
42708     thunk32_vkCmdSetDiscardRectangleEXT,
42709     thunk32_vkCmdSetEvent,
42710     thunk32_vkCmdSetEvent2,
42711     thunk32_vkCmdSetEvent2KHR,
42712     thunk32_vkCmdSetExclusiveScissorNV,
42713     thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
42714     thunk32_vkCmdSetFragmentShadingRateEnumNV,
42715     thunk32_vkCmdSetFragmentShadingRateKHR,
42716     thunk32_vkCmdSetFrontFace,
42717     thunk32_vkCmdSetFrontFaceEXT,
42718     thunk32_vkCmdSetLineRasterizationModeEXT,
42719     thunk32_vkCmdSetLineStippleEXT,
42720     thunk32_vkCmdSetLineStippleEnableEXT,
42721     thunk32_vkCmdSetLineWidth,
42722     thunk32_vkCmdSetLogicOpEXT,
42723     thunk32_vkCmdSetLogicOpEnableEXT,
42724     thunk32_vkCmdSetPatchControlPointsEXT,
42725     thunk32_vkCmdSetPerformanceMarkerINTEL,
42726     thunk32_vkCmdSetPerformanceOverrideINTEL,
42727     thunk32_vkCmdSetPerformanceStreamMarkerINTEL,
42728     thunk32_vkCmdSetPolygonModeEXT,
42729     thunk32_vkCmdSetPrimitiveRestartEnable,
42730     thunk32_vkCmdSetPrimitiveRestartEnableEXT,
42731     thunk32_vkCmdSetPrimitiveTopology,
42732     thunk32_vkCmdSetPrimitiveTopologyEXT,
42733     thunk32_vkCmdSetProvokingVertexModeEXT,
42734     thunk32_vkCmdSetRasterizationSamplesEXT,
42735     thunk32_vkCmdSetRasterizationStreamEXT,
42736     thunk32_vkCmdSetRasterizerDiscardEnable,
42737     thunk32_vkCmdSetRasterizerDiscardEnableEXT,
42738     thunk32_vkCmdSetRayTracingPipelineStackSizeKHR,
42739     thunk32_vkCmdSetRepresentativeFragmentTestEnableNV,
42740     thunk32_vkCmdSetSampleLocationsEXT,
42741     thunk32_vkCmdSetSampleLocationsEnableEXT,
42742     thunk32_vkCmdSetSampleMaskEXT,
42743     thunk32_vkCmdSetScissor,
42744     thunk32_vkCmdSetScissorWithCount,
42745     thunk32_vkCmdSetScissorWithCountEXT,
42746     thunk32_vkCmdSetShadingRateImageEnableNV,
42747     thunk32_vkCmdSetStencilCompareMask,
42748     thunk32_vkCmdSetStencilOp,
42749     thunk32_vkCmdSetStencilOpEXT,
42750     thunk32_vkCmdSetStencilReference,
42751     thunk32_vkCmdSetStencilTestEnable,
42752     thunk32_vkCmdSetStencilTestEnableEXT,
42753     thunk32_vkCmdSetStencilWriteMask,
42754     thunk32_vkCmdSetTessellationDomainOriginEXT,
42755     thunk32_vkCmdSetVertexInputEXT,
42756     thunk32_vkCmdSetViewport,
42757     thunk32_vkCmdSetViewportShadingRatePaletteNV,
42758     thunk32_vkCmdSetViewportSwizzleNV,
42759     thunk32_vkCmdSetViewportWScalingEnableNV,
42760     thunk32_vkCmdSetViewportWScalingNV,
42761     thunk32_vkCmdSetViewportWithCount,
42762     thunk32_vkCmdSetViewportWithCountEXT,
42763     thunk32_vkCmdSubpassShadingHUAWEI,
42764     thunk32_vkCmdTraceRaysIndirect2KHR,
42765     thunk32_vkCmdTraceRaysIndirectKHR,
42766     thunk32_vkCmdTraceRaysKHR,
42767     thunk32_vkCmdTraceRaysNV,
42768     thunk32_vkCmdUpdateBuffer,
42769     thunk32_vkCmdWaitEvents,
42770     thunk32_vkCmdWaitEvents2,
42771     thunk32_vkCmdWaitEvents2KHR,
42772     thunk32_vkCmdWriteAccelerationStructuresPropertiesKHR,
42773     thunk32_vkCmdWriteAccelerationStructuresPropertiesNV,
42774     thunk32_vkCmdWriteBufferMarker2AMD,
42775     thunk32_vkCmdWriteBufferMarkerAMD,
42776     thunk32_vkCmdWriteMicromapsPropertiesEXT,
42777     thunk32_vkCmdWriteTimestamp,
42778     thunk32_vkCmdWriteTimestamp2,
42779     thunk32_vkCmdWriteTimestamp2KHR,
42780     thunk32_vkCompileDeferredNV,
42781     thunk32_vkCopyAccelerationStructureKHR,
42782     thunk32_vkCopyAccelerationStructureToMemoryKHR,
42783     thunk32_vkCopyMemoryToAccelerationStructureKHR,
42784     thunk32_vkCopyMemoryToMicromapEXT,
42785     thunk32_vkCopyMicromapEXT,
42786     thunk32_vkCopyMicromapToMemoryEXT,
42787     thunk32_vkCreateAccelerationStructureKHR,
42788     thunk32_vkCreateAccelerationStructureNV,
42789     thunk32_vkCreateBuffer,
42790     thunk32_vkCreateBufferView,
42791     thunk32_vkCreateCommandPool,
42792     thunk32_vkCreateComputePipelines,
42793     thunk32_vkCreateCuFunctionNVX,
42794     thunk32_vkCreateCuModuleNVX,
42795     thunk32_vkCreateDebugReportCallbackEXT,
42796     thunk32_vkCreateDebugUtilsMessengerEXT,
42797     thunk32_vkCreateDeferredOperationKHR,
42798     thunk32_vkCreateDescriptorPool,
42799     thunk32_vkCreateDescriptorSetLayout,
42800     thunk32_vkCreateDescriptorUpdateTemplate,
42801     thunk32_vkCreateDescriptorUpdateTemplateKHR,
42802     thunk32_vkCreateDevice,
42803     thunk32_vkCreateEvent,
42804     thunk32_vkCreateFence,
42805     thunk32_vkCreateFramebuffer,
42806     thunk32_vkCreateGraphicsPipelines,
42807     thunk32_vkCreateImage,
42808     thunk32_vkCreateImageView,
42809     thunk32_vkCreateIndirectCommandsLayoutNV,
42810     thunk32_vkCreateInstance,
42811     thunk32_vkCreateMicromapEXT,
42812     thunk32_vkCreateOpticalFlowSessionNV,
42813     thunk32_vkCreatePipelineCache,
42814     thunk32_vkCreatePipelineLayout,
42815     thunk32_vkCreatePrivateDataSlot,
42816     thunk32_vkCreatePrivateDataSlotEXT,
42817     thunk32_vkCreateQueryPool,
42818     thunk32_vkCreateRayTracingPipelinesKHR,
42819     thunk32_vkCreateRayTracingPipelinesNV,
42820     thunk32_vkCreateRenderPass,
42821     thunk32_vkCreateRenderPass2,
42822     thunk32_vkCreateRenderPass2KHR,
42823     thunk32_vkCreateSampler,
42824     thunk32_vkCreateSamplerYcbcrConversion,
42825     thunk32_vkCreateSamplerYcbcrConversionKHR,
42826     thunk32_vkCreateSemaphore,
42827     thunk32_vkCreateShaderModule,
42828     thunk32_vkCreateSwapchainKHR,
42829     thunk32_vkCreateValidationCacheEXT,
42830     thunk32_vkCreateWin32SurfaceKHR,
42831     thunk32_vkDebugMarkerSetObjectNameEXT,
42832     thunk32_vkDebugMarkerSetObjectTagEXT,
42833     thunk32_vkDebugReportMessageEXT,
42834     thunk32_vkDeferredOperationJoinKHR,
42835     thunk32_vkDestroyAccelerationStructureKHR,
42836     thunk32_vkDestroyAccelerationStructureNV,
42837     thunk32_vkDestroyBuffer,
42838     thunk32_vkDestroyBufferView,
42839     thunk32_vkDestroyCommandPool,
42840     thunk32_vkDestroyCuFunctionNVX,
42841     thunk32_vkDestroyCuModuleNVX,
42842     thunk32_vkDestroyDebugReportCallbackEXT,
42843     thunk32_vkDestroyDebugUtilsMessengerEXT,
42844     thunk32_vkDestroyDeferredOperationKHR,
42845     thunk32_vkDestroyDescriptorPool,
42846     thunk32_vkDestroyDescriptorSetLayout,
42847     thunk32_vkDestroyDescriptorUpdateTemplate,
42848     thunk32_vkDestroyDescriptorUpdateTemplateKHR,
42849     thunk32_vkDestroyDevice,
42850     thunk32_vkDestroyEvent,
42851     thunk32_vkDestroyFence,
42852     thunk32_vkDestroyFramebuffer,
42853     thunk32_vkDestroyImage,
42854     thunk32_vkDestroyImageView,
42855     thunk32_vkDestroyIndirectCommandsLayoutNV,
42856     thunk32_vkDestroyInstance,
42857     thunk32_vkDestroyMicromapEXT,
42858     thunk32_vkDestroyOpticalFlowSessionNV,
42859     thunk32_vkDestroyPipeline,
42860     thunk32_vkDestroyPipelineCache,
42861     thunk32_vkDestroyPipelineLayout,
42862     thunk32_vkDestroyPrivateDataSlot,
42863     thunk32_vkDestroyPrivateDataSlotEXT,
42864     thunk32_vkDestroyQueryPool,
42865     thunk32_vkDestroyRenderPass,
42866     thunk32_vkDestroySampler,
42867     thunk32_vkDestroySamplerYcbcrConversion,
42868     thunk32_vkDestroySamplerYcbcrConversionKHR,
42869     thunk32_vkDestroySemaphore,
42870     thunk32_vkDestroyShaderModule,
42871     thunk32_vkDestroySurfaceKHR,
42872     thunk32_vkDestroySwapchainKHR,
42873     thunk32_vkDestroyValidationCacheEXT,
42874     thunk32_vkDeviceWaitIdle,
42875     thunk32_vkEndCommandBuffer,
42876     thunk32_vkEnumerateDeviceExtensionProperties,
42877     thunk32_vkEnumerateDeviceLayerProperties,
42878     thunk32_vkEnumerateInstanceExtensionProperties,
42879     thunk32_vkEnumerateInstanceVersion,
42880     thunk32_vkEnumeratePhysicalDeviceGroups,
42881     thunk32_vkEnumeratePhysicalDeviceGroupsKHR,
42882     thunk32_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
42883     thunk32_vkEnumeratePhysicalDevices,
42884     thunk32_vkFlushMappedMemoryRanges,
42885     thunk32_vkFreeCommandBuffers,
42886     thunk32_vkFreeDescriptorSets,
42887     thunk32_vkFreeMemory,
42888     thunk32_vkGetAccelerationStructureBuildSizesKHR,
42889     thunk32_vkGetAccelerationStructureDeviceAddressKHR,
42890     thunk32_vkGetAccelerationStructureHandleNV,
42891     thunk32_vkGetAccelerationStructureMemoryRequirementsNV,
42892     thunk32_vkGetBufferDeviceAddress,
42893     thunk32_vkGetBufferDeviceAddressEXT,
42894     thunk32_vkGetBufferDeviceAddressKHR,
42895     thunk32_vkGetBufferMemoryRequirements,
42896     thunk32_vkGetBufferMemoryRequirements2,
42897     thunk32_vkGetBufferMemoryRequirements2KHR,
42898     thunk32_vkGetBufferOpaqueCaptureAddress,
42899     thunk32_vkGetBufferOpaqueCaptureAddressKHR,
42900     thunk32_vkGetCalibratedTimestampsEXT,
42901     thunk32_vkGetDeferredOperationMaxConcurrencyKHR,
42902     thunk32_vkGetDeferredOperationResultKHR,
42903     thunk32_vkGetDescriptorSetHostMappingVALVE,
42904     thunk32_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
42905     thunk32_vkGetDescriptorSetLayoutSupport,
42906     thunk32_vkGetDescriptorSetLayoutSupportKHR,
42907     thunk32_vkGetDeviceAccelerationStructureCompatibilityKHR,
42908     thunk32_vkGetDeviceBufferMemoryRequirements,
42909     thunk32_vkGetDeviceBufferMemoryRequirementsKHR,
42910     thunk32_vkGetDeviceFaultInfoEXT,
42911     thunk32_vkGetDeviceGroupPeerMemoryFeatures,
42912     thunk32_vkGetDeviceGroupPeerMemoryFeaturesKHR,
42913     thunk32_vkGetDeviceGroupPresentCapabilitiesKHR,
42914     thunk32_vkGetDeviceGroupSurfacePresentModesKHR,
42915     thunk32_vkGetDeviceImageMemoryRequirements,
42916     thunk32_vkGetDeviceImageMemoryRequirementsKHR,
42917     thunk32_vkGetDeviceImageSparseMemoryRequirements,
42918     thunk32_vkGetDeviceImageSparseMemoryRequirementsKHR,
42919     thunk32_vkGetDeviceMemoryCommitment,
42920     thunk32_vkGetDeviceMemoryOpaqueCaptureAddress,
42921     thunk32_vkGetDeviceMemoryOpaqueCaptureAddressKHR,
42922     thunk32_vkGetDeviceMicromapCompatibilityEXT,
42923     thunk32_vkGetDeviceQueue,
42924     thunk32_vkGetDeviceQueue2,
42925     thunk32_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
42926     thunk32_vkGetDynamicRenderingTilePropertiesQCOM,
42927     thunk32_vkGetEventStatus,
42928     thunk32_vkGetFenceStatus,
42929     thunk32_vkGetFramebufferTilePropertiesQCOM,
42930     thunk32_vkGetGeneratedCommandsMemoryRequirementsNV,
42931     thunk32_vkGetImageMemoryRequirements,
42932     thunk32_vkGetImageMemoryRequirements2,
42933     thunk32_vkGetImageMemoryRequirements2KHR,
42934     thunk32_vkGetImageSparseMemoryRequirements,
42935     thunk32_vkGetImageSparseMemoryRequirements2,
42936     thunk32_vkGetImageSparseMemoryRequirements2KHR,
42937     thunk32_vkGetImageSubresourceLayout,
42938     thunk32_vkGetImageSubresourceLayout2EXT,
42939     thunk32_vkGetImageViewAddressNVX,
42940     thunk32_vkGetImageViewHandleNVX,
42941     thunk32_vkGetMemoryHostPointerPropertiesEXT,
42942     thunk32_vkGetMicromapBuildSizesEXT,
42943     thunk32_vkGetPerformanceParameterINTEL,
42944     thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
42945     thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
42946     thunk32_vkGetPhysicalDeviceExternalBufferProperties,
42947     thunk32_vkGetPhysicalDeviceExternalBufferPropertiesKHR,
42948     thunk32_vkGetPhysicalDeviceExternalFenceProperties,
42949     thunk32_vkGetPhysicalDeviceExternalFencePropertiesKHR,
42950     thunk32_vkGetPhysicalDeviceExternalSemaphoreProperties,
42951     thunk32_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,
42952     thunk32_vkGetPhysicalDeviceFeatures,
42953     thunk32_vkGetPhysicalDeviceFeatures2,
42954     thunk32_vkGetPhysicalDeviceFeatures2KHR,
42955     thunk32_vkGetPhysicalDeviceFormatProperties,
42956     thunk32_vkGetPhysicalDeviceFormatProperties2,
42957     thunk32_vkGetPhysicalDeviceFormatProperties2KHR,
42958     thunk32_vkGetPhysicalDeviceFragmentShadingRatesKHR,
42959     thunk32_vkGetPhysicalDeviceImageFormatProperties,
42960     thunk32_vkGetPhysicalDeviceImageFormatProperties2,
42961     thunk32_vkGetPhysicalDeviceImageFormatProperties2KHR,
42962     thunk32_vkGetPhysicalDeviceMemoryProperties,
42963     thunk32_vkGetPhysicalDeviceMemoryProperties2,
42964     thunk32_vkGetPhysicalDeviceMemoryProperties2KHR,
42965     thunk32_vkGetPhysicalDeviceMultisamplePropertiesEXT,
42966     thunk32_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
42967     thunk32_vkGetPhysicalDevicePresentRectanglesKHR,
42968     thunk32_vkGetPhysicalDeviceProperties,
42969     thunk32_vkGetPhysicalDeviceProperties2,
42970     thunk32_vkGetPhysicalDeviceProperties2KHR,
42971     thunk32_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
42972     thunk32_vkGetPhysicalDeviceQueueFamilyProperties,
42973     thunk32_vkGetPhysicalDeviceQueueFamilyProperties2,
42974     thunk32_vkGetPhysicalDeviceQueueFamilyProperties2KHR,
42975     thunk32_vkGetPhysicalDeviceSparseImageFormatProperties,
42976     thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2,
42977     thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,
42978     thunk32_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
42979     thunk32_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
42980     thunk32_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
42981     thunk32_vkGetPhysicalDeviceSurfaceFormats2KHR,
42982     thunk32_vkGetPhysicalDeviceSurfaceFormatsKHR,
42983     thunk32_vkGetPhysicalDeviceSurfacePresentModesKHR,
42984     thunk32_vkGetPhysicalDeviceSurfaceSupportKHR,
42985     thunk32_vkGetPhysicalDeviceToolProperties,
42986     thunk32_vkGetPhysicalDeviceToolPropertiesEXT,
42987     thunk32_vkGetPhysicalDeviceWin32PresentationSupportKHR,
42988     thunk32_vkGetPipelineCacheData,
42989     thunk32_vkGetPipelineExecutableInternalRepresentationsKHR,
42990     thunk32_vkGetPipelineExecutablePropertiesKHR,
42991     thunk32_vkGetPipelineExecutableStatisticsKHR,
42992     thunk32_vkGetPipelinePropertiesEXT,
42993     thunk32_vkGetPrivateData,
42994     thunk32_vkGetPrivateDataEXT,
42995     thunk32_vkGetQueryPoolResults,
42996     thunk32_vkGetQueueCheckpointData2NV,
42997     thunk32_vkGetQueueCheckpointDataNV,
42998     thunk32_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
42999     thunk32_vkGetRayTracingShaderGroupHandlesKHR,
43000     thunk32_vkGetRayTracingShaderGroupHandlesNV,
43001     thunk32_vkGetRayTracingShaderGroupStackSizeKHR,
43002     thunk32_vkGetRenderAreaGranularity,
43003     thunk32_vkGetSemaphoreCounterValue,
43004     thunk32_vkGetSemaphoreCounterValueKHR,
43005     thunk32_vkGetShaderInfoAMD,
43006     thunk32_vkGetShaderModuleCreateInfoIdentifierEXT,
43007     thunk32_vkGetShaderModuleIdentifierEXT,
43008     thunk32_vkGetSwapchainImagesKHR,
43009     thunk32_vkGetValidationCacheDataEXT,
43010     thunk32_vkInitializePerformanceApiINTEL,
43011     thunk32_vkInvalidateMappedMemoryRanges,
43012     thunk32_vkMapMemory,
43013     thunk32_vkMergePipelineCaches,
43014     thunk32_vkMergeValidationCachesEXT,
43015     thunk32_vkQueueBeginDebugUtilsLabelEXT,
43016     thunk32_vkQueueBindSparse,
43017     thunk32_vkQueueEndDebugUtilsLabelEXT,
43018     thunk32_vkQueueInsertDebugUtilsLabelEXT,
43019     thunk32_vkQueuePresentKHR,
43020     thunk32_vkQueueSetPerformanceConfigurationINTEL,
43021     thunk32_vkQueueSubmit,
43022     thunk32_vkQueueSubmit2,
43023     thunk32_vkQueueSubmit2KHR,
43024     thunk32_vkQueueWaitIdle,
43025     thunk32_vkReleasePerformanceConfigurationINTEL,
43026     thunk32_vkReleaseProfilingLockKHR,
43027     thunk32_vkResetCommandBuffer,
43028     thunk32_vkResetCommandPool,
43029     thunk32_vkResetDescriptorPool,
43030     thunk32_vkResetEvent,
43031     thunk32_vkResetFences,
43032     thunk32_vkResetQueryPool,
43033     thunk32_vkResetQueryPoolEXT,
43034     thunk32_vkSetDebugUtilsObjectNameEXT,
43035     thunk32_vkSetDebugUtilsObjectTagEXT,
43036     thunk32_vkSetDeviceMemoryPriorityEXT,
43037     thunk32_vkSetEvent,
43038     thunk32_vkSetPrivateData,
43039     thunk32_vkSetPrivateDataEXT,
43040     thunk32_vkSignalSemaphore,
43041     thunk32_vkSignalSemaphoreKHR,
43042     thunk32_vkSubmitDebugUtilsMessageEXT,
43043     thunk32_vkTrimCommandPool,
43044     thunk32_vkTrimCommandPoolKHR,
43045     thunk32_vkUninitializePerformanceApiINTEL,
43046     thunk32_vkUnmapMemory,
43047     thunk32_vkUpdateDescriptorSetWithTemplate,
43048     thunk32_vkUpdateDescriptorSetWithTemplateKHR,
43049     thunk32_vkUpdateDescriptorSets,
43050     thunk32_vkWaitForFences,
43051     thunk32_vkWaitForPresentKHR,
43052     thunk32_vkWaitSemaphores,
43053     thunk32_vkWaitSemaphoresKHR,
43054     thunk32_vkWriteAccelerationStructuresPropertiesKHR,
43055     thunk32_vkWriteMicromapsPropertiesEXT,
43056 };
43057 C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);
43058
43059 #endif /* USE_STRUCT_CONVERSION) */
43060
43061 NTSTATUS WINAPI vk_direct_unix_call(unixlib_handle_t handle, unsigned int code, void *params)
43062 {
43063     return __wine_unix_call_funcs[code](params);
43064 }