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-2023 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 typedef struct VkAcquireNextImageInfoKHR32
  25 {
  26     VkStructureType sType;
  27     PTR32 pNext;
  28     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
  29     uint64_t DECLSPEC_ALIGN(8) timeout;
  30     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
  31     VkFence DECLSPEC_ALIGN(8) fence;
  32     uint32_t deviceMask;
  33 } VkAcquireNextImageInfoKHR32;
  34
  35 typedef struct VkPerformanceConfigurationAcquireInfoINTEL32
  36 {
  37     VkStructureType sType;
  38     PTR32 pNext;
  39     VkPerformanceConfigurationTypeINTEL type;
  40 } VkPerformanceConfigurationAcquireInfoINTEL32;
  41
  42 typedef struct VkAcquireProfilingLockInfoKHR32
  43 {
  44     VkStructureType sType;
  45     PTR32 pNext;
  46     VkAcquireProfilingLockFlagsKHR flags;
  47     uint64_t DECLSPEC_ALIGN(8) timeout;
  48 } VkAcquireProfilingLockInfoKHR32;
  49
  50 typedef struct VkCommandBufferAllocateInfo32
  51 {
  52     VkStructureType sType;
  53     PTR32 pNext;
  54     VkCommandPool DECLSPEC_ALIGN(8) commandPool;
  55     VkCommandBufferLevel level;
  56     uint32_t commandBufferCount;
  57 } VkCommandBufferAllocateInfo32;
  58
  59 typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo32
  60 {
  61     VkStructureType sType;
  62     PTR32 pNext;
  63     uint32_t descriptorSetCount;
  64     PTR32 pDescriptorCounts;
  65 } VkDescriptorSetVariableDescriptorCountAllocateInfo32;
  66 typedef VkDescriptorSetVariableDescriptorCountAllocateInfo32 VkDescriptorSetVariableDescriptorCountAllocateInfoEXT32;
  67
  68 typedef struct VkDescriptorSetAllocateInfo32
  69 {
  70     VkStructureType sType;
  71     PTR32 pNext;
  72     VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
  73     uint32_t descriptorSetCount;
  74     PTR32 pSetLayouts;
  75 } VkDescriptorSetAllocateInfo32;
  76
  77 typedef struct VkDedicatedAllocationMemoryAllocateInfoNV32
  78 {
  79     VkStructureType sType;
  80     PTR32 pNext;
  81     VkImage DECLSPEC_ALIGN(8) image;
  82     VkBuffer DECLSPEC_ALIGN(8) buffer;
  83 } VkDedicatedAllocationMemoryAllocateInfoNV32;
  84
  85 typedef struct VkExportMemoryAllocateInfo32
  86 {
  87     VkStructureType sType;
  88     PTR32 pNext;
  89     VkExternalMemoryHandleTypeFlags handleTypes;
  90 } VkExportMemoryAllocateInfo32;
  91 typedef VkExportMemoryAllocateInfo32 VkExportMemoryAllocateInfoKHR32;
  92
  93 typedef struct VkImportMemoryWin32HandleInfoKHR32
  94 {
  95     VkStructureType sType;
  96     PTR32 pNext;
  97     VkExternalMemoryHandleTypeFlagBits handleType;
  98     HANDLE handle;
  99     LPCWSTR name;
 100 } VkImportMemoryWin32HandleInfoKHR32;
 101
 102 typedef struct VkExportMemoryWin32HandleInfoKHR32
 103 {
 104     VkStructureType sType;
 105     PTR32 pNext;
 106     PTR32 pAttributes;
 107     DWORD dwAccess;
 108     LPCWSTR name;
 109 } VkExportMemoryWin32HandleInfoKHR32;
 110
 111 typedef struct VkMemoryAllocateFlagsInfo32
 112 {
 113     VkStructureType sType;
 114     PTR32 pNext;
 115     VkMemoryAllocateFlags flags;
 116     uint32_t deviceMask;
 117 } VkMemoryAllocateFlagsInfo32;
 118 typedef VkMemoryAllocateFlagsInfo32 VkMemoryAllocateFlagsInfoKHR32;
 119
 120 typedef struct VkMemoryDedicatedAllocateInfo32
 121 {
 122     VkStructureType sType;
 123     PTR32 pNext;
 124     VkImage DECLSPEC_ALIGN(8) image;
 125     VkBuffer DECLSPEC_ALIGN(8) buffer;
 126 } VkMemoryDedicatedAllocateInfo32;
 127 typedef VkMemoryDedicatedAllocateInfo32 VkMemoryDedicatedAllocateInfoKHR32;
 128
 129 typedef struct VkImportMemoryHostPointerInfoEXT32
 130 {
 131     VkStructureType sType;
 132     PTR32 pNext;
 133     VkExternalMemoryHandleTypeFlagBits handleType;
 134     PTR32 pHostPointer;
 135 } VkImportMemoryHostPointerInfoEXT32;
 136
 137 typedef struct VkMemoryPriorityAllocateInfoEXT32
 138 {
 139     VkStructureType sType;
 140     PTR32 pNext;
 141     float priority;
 142 } VkMemoryPriorityAllocateInfoEXT32;
 143
 144 typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo32
 145 {
 146     VkStructureType sType;
 147     PTR32 pNext;
 148     uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress;
 149 } VkMemoryOpaqueCaptureAddressAllocateInfo32;
 150 typedef VkMemoryOpaqueCaptureAddressAllocateInfo32 VkMemoryOpaqueCaptureAddressAllocateInfoKHR32;
 151
 152 typedef struct VkMemoryAllocateInfo32
 153 {
 154     VkStructureType sType;
 155     PTR32 pNext;
 156     VkDeviceSize DECLSPEC_ALIGN(8) allocationSize;
 157     uint32_t memoryTypeIndex;
 158 } VkMemoryAllocateInfo32;
 159
 160 typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT32
 161 {
 162     VkStructureType sType;
 163     PTR32 pNext;
 164     VkBool32 conditionalRenderingEnable;
 165 } VkCommandBufferInheritanceConditionalRenderingInfoEXT32;
 166
 167 typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM32
 168 {
 169     VkStructureType sType;
 170     PTR32 pNext;
 171     VkSurfaceTransformFlagBitsKHR transform;
 172     VkRect2D renderArea;
 173 } VkCommandBufferInheritanceRenderPassTransformInfoQCOM32;
 174
 175 typedef struct VkCommandBufferInheritanceViewportScissorInfoNV32
 176 {
 177     VkStructureType sType;
 178     PTR32 pNext;
 179     VkBool32 viewportScissor2D;
 180     uint32_t viewportDepthCount;
 181     PTR32 pViewportDepths;
 182 } VkCommandBufferInheritanceViewportScissorInfoNV32;
 183
 184 typedef struct VkCommandBufferInheritanceRenderingInfo32
 185 {
 186     VkStructureType sType;
 187     PTR32 pNext;
 188     VkRenderingFlags flags;
 189     uint32_t viewMask;
 190     uint32_t colorAttachmentCount;
 191     PTR32 pColorAttachmentFormats;
 192     VkFormat depthAttachmentFormat;
 193     VkFormat stencilAttachmentFormat;
 194     VkSampleCountFlagBits rasterizationSamples;
 195 } VkCommandBufferInheritanceRenderingInfo32;
 196 typedef VkCommandBufferInheritanceRenderingInfo32 VkCommandBufferInheritanceRenderingInfoKHR32;
 197
 198 typedef struct VkAttachmentSampleCountInfoAMD32
 199 {
 200     VkStructureType sType;
 201     PTR32 pNext;
 202     uint32_t colorAttachmentCount;
 203     PTR32 pColorAttachmentSamples;
 204     VkSampleCountFlagBits depthStencilAttachmentSamples;
 205 } VkAttachmentSampleCountInfoAMD32;
 206 typedef VkAttachmentSampleCountInfoAMD32 VkAttachmentSampleCountInfoNV32;
 207
 208 typedef struct VkMultiviewPerViewAttributesInfoNVX32
 209 {
 210     VkStructureType sType;
 211     PTR32 pNext;
 212     VkBool32 perViewAttributes;
 213     VkBool32 perViewAttributesPositionXOnly;
 214 } VkMultiviewPerViewAttributesInfoNVX32;
 215
 216 typedef struct VkCommandBufferInheritanceInfo32
 217 {
 218     VkStructureType sType;
 219     PTR32 pNext;
 220     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
 221     uint32_t subpass;
 222     VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
 223     VkBool32 occlusionQueryEnable;
 224     VkQueryControlFlags queryFlags;
 225     VkQueryPipelineStatisticFlags pipelineStatistics;
 226 } VkCommandBufferInheritanceInfo32;
 227
 228 typedef struct VkDeviceGroupCommandBufferBeginInfo32
 229 {
 230     VkStructureType sType;
 231     PTR32 pNext;
 232     uint32_t deviceMask;
 233 } VkDeviceGroupCommandBufferBeginInfo32;
 234 typedef VkDeviceGroupCommandBufferBeginInfo32 VkDeviceGroupCommandBufferBeginInfoKHR32;
 235
 236 typedef struct VkCommandBufferBeginInfo32
 237 {
 238     VkStructureType sType;
 239     PTR32 pNext;
 240     VkCommandBufferUsageFlags flags;
 241     PTR32 pInheritanceInfo;
 242 } VkCommandBufferBeginInfo32;
 243
 244 typedef struct VkBindAccelerationStructureMemoryInfoNV32
 245 {
 246     VkStructureType sType;
 247     PTR32 pNext;
 248     VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
 249     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
 250     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
 251     uint32_t deviceIndexCount;
 252     PTR32 pDeviceIndices;
 253 } VkBindAccelerationStructureMemoryInfoNV32;
 254
 255 typedef struct VkBindBufferMemoryDeviceGroupInfo32
 256 {
 257     VkStructureType sType;
 258     PTR32 pNext;
 259     uint32_t deviceIndexCount;
 260     PTR32 pDeviceIndices;
 261 } VkBindBufferMemoryDeviceGroupInfo32;
 262 typedef VkBindBufferMemoryDeviceGroupInfo32 VkBindBufferMemoryDeviceGroupInfoKHR32;
 263
 264 typedef struct VkBindBufferMemoryInfo32
 265 {
 266     VkStructureType sType;
 267     PTR32 pNext;
 268     VkBuffer DECLSPEC_ALIGN(8) buffer;
 269     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
 270     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
 271 } VkBindBufferMemoryInfo32;
 272 typedef VkBindBufferMemoryInfo32 VkBindBufferMemoryInfoKHR32;
 273
 274 typedef struct VkBindImageMemoryDeviceGroupInfo32
 275 {
 276     VkStructureType sType;
 277     PTR32 pNext;
 278     uint32_t deviceIndexCount;
 279     PTR32 pDeviceIndices;
 280     uint32_t splitInstanceBindRegionCount;
 281     PTR32 pSplitInstanceBindRegions;
 282 } VkBindImageMemoryDeviceGroupInfo32;
 283 typedef VkBindImageMemoryDeviceGroupInfo32 VkBindImageMemoryDeviceGroupInfoKHR32;
 284
 285 typedef struct VkBindImageMemorySwapchainInfoKHR32
 286 {
 287     VkStructureType sType;
 288     PTR32 pNext;
 289     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
 290     uint32_t imageIndex;
 291 } VkBindImageMemorySwapchainInfoKHR32;
 292
 293 typedef struct VkBindImagePlaneMemoryInfo32
 294 {
 295     VkStructureType sType;
 296     PTR32 pNext;
 297     VkImageAspectFlagBits planeAspect;
 298 } VkBindImagePlaneMemoryInfo32;
 299 typedef VkBindImagePlaneMemoryInfo32 VkBindImagePlaneMemoryInfoKHR32;
 300
 301 typedef struct VkBindImageMemoryInfo32
 302 {
 303     VkStructureType sType;
 304     PTR32 pNext;
 305     VkImage DECLSPEC_ALIGN(8) image;
 306     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
 307     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
 308 } VkBindImageMemoryInfo32;
 309 typedef VkBindImageMemoryInfo32 VkBindImageMemoryInfoKHR32;
 310
 311 typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV32
 312 {
 313     VkStructureType sType;
 314     PTR32 pNext;
 315     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData;
 316 } VkAccelerationStructureGeometryMotionTrianglesDataNV32;
 317
 318 typedef struct VkAccelerationStructureTrianglesOpacityMicromapEXT32
 319 {
 320     VkStructureType sType;
 321     PTR32 pNext;
 322     VkIndexType indexType;
 323     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexBuffer;
 324     VkDeviceSize DECLSPEC_ALIGN(8) indexStride;
 325     uint32_t baseTriangle;
 326     uint32_t usageCountsCount;
 327     PTR32 pUsageCounts;
 328     PTR32 ppUsageCounts;
 329     VkMicromapEXT DECLSPEC_ALIGN(8) micromap;
 330 } VkAccelerationStructureTrianglesOpacityMicromapEXT32;
 331
 332 typedef struct VkAccelerationStructureGeometryTrianglesDataKHR32
 333 {
 334     VkStructureType sType;
 335     PTR32 pNext;
 336     VkFormat vertexFormat;
 337     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData;
 338     VkDeviceSize DECLSPEC_ALIGN(8) vertexStride;
 339     uint32_t maxVertex;
 340     VkIndexType indexType;
 341     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexData;
 342     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) transformData;
 343 } VkAccelerationStructureGeometryTrianglesDataKHR32;
 344
 345 typedef struct VkAccelerationStructureGeometryAabbsDataKHR32
 346 {
 347     VkStructureType sType;
 348     PTR32 pNext;
 349     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data;
 350     VkDeviceSize DECLSPEC_ALIGN(8) stride;
 351 } VkAccelerationStructureGeometryAabbsDataKHR32;
 352
 353 typedef struct VkAccelerationStructureGeometryInstancesDataKHR32
 354 {
 355     VkStructureType sType;
 356     PTR32 pNext;
 357     VkBool32 arrayOfPointers;
 358     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data;
 359 } VkAccelerationStructureGeometryInstancesDataKHR32;
 360
 361 typedef union VkAccelerationStructureGeometryDataKHR32
 362 {
 363     VkAccelerationStructureGeometryTrianglesDataKHR32 DECLSPEC_ALIGN(8) triangles;
 364     VkAccelerationStructureGeometryAabbsDataKHR32 DECLSPEC_ALIGN(8) aabbs;
 365     VkAccelerationStructureGeometryInstancesDataKHR32 DECLSPEC_ALIGN(8) instances;
 366 } VkAccelerationStructureGeometryDataKHR32;
 367
 368 typedef struct VkAccelerationStructureGeometryKHR32
 369 {
 370     VkStructureType sType;
 371     PTR32 pNext;
 372     VkGeometryTypeKHR geometryType;
 373     VkAccelerationStructureGeometryDataKHR32 DECLSPEC_ALIGN(8) geometry;
 374     VkGeometryFlagsKHR flags;
 375 } VkAccelerationStructureGeometryKHR32;
 376
 377 typedef struct VkAccelerationStructureBuildGeometryInfoKHR32
 378 {
 379     VkStructureType sType;
 380     PTR32 pNext;
 381     VkAccelerationStructureTypeKHR type;
 382     VkBuildAccelerationStructureFlagsKHR flags;
 383     VkBuildAccelerationStructureModeKHR mode;
 384     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) srcAccelerationStructure;
 385     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dstAccelerationStructure;
 386     uint32_t geometryCount;
 387     PTR32 pGeometries;
 388     PTR32 ppGeometries;
 389     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData;
 390 } VkAccelerationStructureBuildGeometryInfoKHR32;
 391
 392 typedef struct VkMicromapBuildInfoEXT32
 393 {
 394     VkStructureType sType;
 395     PTR32 pNext;
 396     VkMicromapTypeEXT type;
 397     VkBuildMicromapFlagsEXT flags;
 398     VkBuildMicromapModeEXT mode;
 399     VkMicromapEXT DECLSPEC_ALIGN(8) dstMicromap;
 400     uint32_t usageCountsCount;
 401     PTR32 pUsageCounts;
 402     PTR32 ppUsageCounts;
 403     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data;
 404     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData;
 405     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) triangleArray;
 406     VkDeviceSize DECLSPEC_ALIGN(8) triangleArrayStride;
 407 } VkMicromapBuildInfoEXT32;
 408
 409 typedef struct VkConditionalRenderingBeginInfoEXT32
 410 {
 411     VkStructureType sType;
 412     PTR32 pNext;
 413     VkBuffer DECLSPEC_ALIGN(8) buffer;
 414     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 415     VkConditionalRenderingFlagsEXT flags;
 416 } VkConditionalRenderingBeginInfoEXT32;
 417
 418 typedef struct VkDebugUtilsLabelEXT32
 419 {
 420     VkStructureType sType;
 421     PTR32 pNext;
 422     PTR32 pLabelName;
 423     float color[4];
 424 } VkDebugUtilsLabelEXT32;
 425
 426 typedef struct VkSampleLocationsInfoEXT32
 427 {
 428     VkStructureType sType;
 429     PTR32 pNext;
 430     VkSampleCountFlagBits sampleLocationsPerPixel;
 431     VkExtent2D sampleLocationGridSize;
 432     uint32_t sampleLocationsCount;
 433     PTR32 pSampleLocations;
 434 } VkSampleLocationsInfoEXT32;
 435
 436 typedef struct VkAttachmentSampleLocationsEXT32
 437 {
 438     uint32_t attachmentIndex;
 439     VkSampleLocationsInfoEXT32 sampleLocationsInfo;
 440 } VkAttachmentSampleLocationsEXT32;
 441
 442 typedef struct VkSubpassSampleLocationsEXT32
 443 {
 444     uint32_t subpassIndex;
 445     VkSampleLocationsInfoEXT32 sampleLocationsInfo;
 446 } VkSubpassSampleLocationsEXT32;
 447
 448 typedef struct VkDeviceGroupRenderPassBeginInfo32
 449 {
 450     VkStructureType sType;
 451     PTR32 pNext;
 452     uint32_t deviceMask;
 453     uint32_t deviceRenderAreaCount;
 454     PTR32 pDeviceRenderAreas;
 455 } VkDeviceGroupRenderPassBeginInfo32;
 456 typedef VkDeviceGroupRenderPassBeginInfo32 VkDeviceGroupRenderPassBeginInfoKHR32;
 457
 458 typedef struct VkRenderPassSampleLocationsBeginInfoEXT32
 459 {
 460     VkStructureType sType;
 461     PTR32 pNext;
 462     uint32_t attachmentInitialSampleLocationsCount;
 463     PTR32 pAttachmentInitialSampleLocations;
 464     uint32_t postSubpassSampleLocationsCount;
 465     PTR32 pPostSubpassSampleLocations;
 466 } VkRenderPassSampleLocationsBeginInfoEXT32;
 467
 468 typedef struct VkRenderPassAttachmentBeginInfo32
 469 {
 470     VkStructureType sType;
 471     PTR32 pNext;
 472     uint32_t attachmentCount;
 473     PTR32 pAttachments;
 474 } VkRenderPassAttachmentBeginInfo32;
 475 typedef VkRenderPassAttachmentBeginInfo32 VkRenderPassAttachmentBeginInfoKHR32;
 476
 477 typedef struct VkRenderPassTransformBeginInfoQCOM32
 478 {
 479     VkStructureType sType;
 480     PTR32 pNext;
 481     VkSurfaceTransformFlagBitsKHR transform;
 482 } VkRenderPassTransformBeginInfoQCOM32;
 483
 484 typedef struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32
 485 {
 486     VkStructureType sType;
 487     PTR32 pNext;
 488     uint32_t perViewRenderAreaCount;
 489     PTR32 pPerViewRenderAreas;
 490 } VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32;
 491
 492 typedef struct VkRenderPassBeginInfo32
 493 {
 494     VkStructureType sType;
 495     PTR32 pNext;
 496     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
 497     VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
 498     VkRect2D renderArea;
 499     uint32_t clearValueCount;
 500     PTR32 pClearValues;
 501 } VkRenderPassBeginInfo32;
 502
 503 typedef struct VkSubpassBeginInfo32
 504 {
 505     VkStructureType sType;
 506     PTR32 pNext;
 507     VkSubpassContents contents;
 508 } VkSubpassBeginInfo32;
 509 typedef VkSubpassBeginInfo32 VkSubpassBeginInfoKHR32;
 510
 511 typedef struct VkRenderingAttachmentInfo32
 512 {
 513     VkStructureType sType;
 514     PTR32 pNext;
 515     VkImageView DECLSPEC_ALIGN(8) imageView;
 516     VkImageLayout imageLayout;
 517     VkResolveModeFlagBits resolveMode;
 518     VkImageView DECLSPEC_ALIGN(8) resolveImageView;
 519     VkImageLayout resolveImageLayout;
 520     VkAttachmentLoadOp loadOp;
 521     VkAttachmentStoreOp storeOp;
 522     VkClearValue clearValue;
 523 } VkRenderingAttachmentInfo32;
 524 typedef VkRenderingAttachmentInfo32 VkRenderingAttachmentInfoKHR32;
 525
 526 typedef struct VkMultisampledRenderToSingleSampledInfoEXT32
 527 {
 528     VkStructureType sType;
 529     PTR32 pNext;
 530     VkBool32 multisampledRenderToSingleSampledEnable;
 531     VkSampleCountFlagBits rasterizationSamples;
 532 } VkMultisampledRenderToSingleSampledInfoEXT32;
 533
 534 typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR32
 535 {
 536     VkStructureType sType;
 537     PTR32 pNext;
 538     VkImageView DECLSPEC_ALIGN(8) imageView;
 539     VkImageLayout imageLayout;
 540     VkExtent2D shadingRateAttachmentTexelSize;
 541 } VkRenderingFragmentShadingRateAttachmentInfoKHR32;
 542
 543 typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT32
 544 {
 545     VkStructureType sType;
 546     PTR32 pNext;
 547     VkImageView DECLSPEC_ALIGN(8) imageView;
 548     VkImageLayout imageLayout;
 549 } VkRenderingFragmentDensityMapAttachmentInfoEXT32;
 550
 551 typedef struct VkRenderingInfo32
 552 {
 553     VkStructureType sType;
 554     PTR32 pNext;
 555     VkRenderingFlags flags;
 556     VkRect2D renderArea;
 557     uint32_t layerCount;
 558     uint32_t viewMask;
 559     uint32_t colorAttachmentCount;
 560     PTR32 pColorAttachments;
 561     PTR32 pDepthAttachment;
 562     PTR32 pStencilAttachment;
 563 } VkRenderingInfo32;
 564 typedef VkRenderingInfo32 VkRenderingInfoKHR32;
 565
 566 typedef struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32
 567 {
 568     VkStructureType sType;
 569     PTR32 pNext;
 570     VkBuffer DECLSPEC_ALIGN(8) buffer;
 571 } VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32;
 572
 573 typedef struct VkDescriptorBufferBindingInfoEXT32
 574 {
 575     VkStructureType sType;
 576     PTR32 pNext;
 577     VkDeviceAddress DECLSPEC_ALIGN(8) address;
 578     VkBufferUsageFlags usage;
 579 } VkDescriptorBufferBindingInfoEXT32;
 580
 581 typedef struct VkCopyCommandTransformInfoQCOM32
 582 {
 583     VkStructureType sType;
 584     PTR32 pNext;
 585     VkSurfaceTransformFlagBitsKHR transform;
 586 } VkCopyCommandTransformInfoQCOM32;
 587
 588 typedef struct VkImageBlit232
 589 {
 590     VkStructureType sType;
 591     PTR32 pNext;
 592     VkImageSubresourceLayers srcSubresource;
 593     VkOffset3D srcOffsets[2];
 594     VkImageSubresourceLayers dstSubresource;
 595     VkOffset3D dstOffsets[2];
 596 } VkImageBlit232;
 597 typedef VkImageBlit232 VkImageBlit2KHR32;
 598
 599 typedef struct VkBlitImageInfo232
 600 {
 601     VkStructureType sType;
 602     PTR32 pNext;
 603     VkImage DECLSPEC_ALIGN(8) srcImage;
 604     VkImageLayout srcImageLayout;
 605     VkImage DECLSPEC_ALIGN(8) dstImage;
 606     VkImageLayout dstImageLayout;
 607     uint32_t regionCount;
 608     PTR32 pRegions;
 609     VkFilter filter;
 610 } VkBlitImageInfo232;
 611 typedef VkBlitImageInfo232 VkBlitImageInfo2KHR32;
 612
 613 typedef struct VkGeometryTrianglesNV32
 614 {
 615     VkStructureType sType;
 616     PTR32 pNext;
 617     VkBuffer DECLSPEC_ALIGN(8) vertexData;
 618     VkDeviceSize DECLSPEC_ALIGN(8) vertexOffset;
 619     uint32_t vertexCount;
 620     VkDeviceSize DECLSPEC_ALIGN(8) vertexStride;
 621     VkFormat vertexFormat;
 622     VkBuffer DECLSPEC_ALIGN(8) indexData;
 623     VkDeviceSize DECLSPEC_ALIGN(8) indexOffset;
 624     uint32_t indexCount;
 625     VkIndexType indexType;
 626     VkBuffer DECLSPEC_ALIGN(8) transformData;
 627     VkDeviceSize DECLSPEC_ALIGN(8) transformOffset;
 628 } VkGeometryTrianglesNV32;
 629
 630 typedef struct VkGeometryAABBNV32
 631 {
 632     VkStructureType sType;
 633     PTR32 pNext;
 634     VkBuffer DECLSPEC_ALIGN(8) aabbData;
 635     uint32_t numAABBs;
 636     uint32_t stride;
 637     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 638 } VkGeometryAABBNV32;
 639
 640 typedef struct VkGeometryDataNV32
 641 {
 642     VkGeometryTrianglesNV32 DECLSPEC_ALIGN(8) triangles;
 643     VkGeometryAABBNV32 DECLSPEC_ALIGN(8) aabbs;
 644 } VkGeometryDataNV32;
 645
 646 typedef struct VkGeometryNV32
 647 {
 648     VkStructureType sType;
 649     PTR32 pNext;
 650     VkGeometryTypeKHR geometryType;
 651     VkGeometryDataNV32 DECLSPEC_ALIGN(8) geometry;
 652     VkGeometryFlagsKHR flags;
 653 } VkGeometryNV32;
 654
 655 typedef struct VkAccelerationStructureInfoNV32
 656 {
 657     VkStructureType sType;
 658     PTR32 pNext;
 659     VkAccelerationStructureTypeNV type;
 660     VkBuildAccelerationStructureFlagsNV flags;
 661     uint32_t instanceCount;
 662     uint32_t geometryCount;
 663     PTR32 pGeometries;
 664 } VkAccelerationStructureInfoNV32;
 665
 666 typedef struct VkCopyAccelerationStructureInfoKHR32
 667 {
 668     VkStructureType sType;
 669     PTR32 pNext;
 670     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src;
 671     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst;
 672     VkCopyAccelerationStructureModeKHR mode;
 673 } VkCopyAccelerationStructureInfoKHR32;
 674
 675 typedef struct VkCopyAccelerationStructureToMemoryInfoKHR32
 676 {
 677     VkStructureType sType;
 678     PTR32 pNext;
 679     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src;
 680     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst;
 681     VkCopyAccelerationStructureModeKHR mode;
 682 } VkCopyAccelerationStructureToMemoryInfoKHR32;
 683
 684 typedef struct VkBufferCopy32
 685 {
 686     VkDeviceSize DECLSPEC_ALIGN(8) srcOffset;
 687     VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
 688     VkDeviceSize DECLSPEC_ALIGN(8) size;
 689 } VkBufferCopy32;
 690
 691 typedef struct VkBufferCopy232
 692 {
 693     VkStructureType sType;
 694     PTR32 pNext;
 695     VkDeviceSize DECLSPEC_ALIGN(8) srcOffset;
 696     VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
 697     VkDeviceSize DECLSPEC_ALIGN(8) size;
 698 } VkBufferCopy232;
 699 typedef VkBufferCopy232 VkBufferCopy2KHR32;
 700
 701 typedef struct VkCopyBufferInfo232
 702 {
 703     VkStructureType sType;
 704     PTR32 pNext;
 705     VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
 706     VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
 707     uint32_t regionCount;
 708     PTR32 pRegions;
 709 } VkCopyBufferInfo232;
 710 typedef VkCopyBufferInfo232 VkCopyBufferInfo2KHR32;
 711
 712 typedef struct VkBufferImageCopy32
 713 {
 714     VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset;
 715     uint32_t bufferRowLength;
 716     uint32_t bufferImageHeight;
 717     VkImageSubresourceLayers imageSubresource;
 718     VkOffset3D imageOffset;
 719     VkExtent3D imageExtent;
 720 } VkBufferImageCopy32;
 721
 722 typedef struct VkBufferImageCopy232
 723 {
 724     VkStructureType sType;
 725     PTR32 pNext;
 726     VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset;
 727     uint32_t bufferRowLength;
 728     uint32_t bufferImageHeight;
 729     VkImageSubresourceLayers imageSubresource;
 730     VkOffset3D imageOffset;
 731     VkExtent3D imageExtent;
 732 } VkBufferImageCopy232;
 733 typedef VkBufferImageCopy232 VkBufferImageCopy2KHR32;
 734
 735 typedef struct VkCopyBufferToImageInfo232
 736 {
 737     VkStructureType sType;
 738     PTR32 pNext;
 739     VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
 740     VkImage DECLSPEC_ALIGN(8) dstImage;
 741     VkImageLayout dstImageLayout;
 742     uint32_t regionCount;
 743     PTR32 pRegions;
 744 } VkCopyBufferToImageInfo232;
 745 typedef VkCopyBufferToImageInfo232 VkCopyBufferToImageInfo2KHR32;
 746
 747 typedef struct VkImageCopy232
 748 {
 749     VkStructureType sType;
 750     PTR32 pNext;
 751     VkImageSubresourceLayers srcSubresource;
 752     VkOffset3D srcOffset;
 753     VkImageSubresourceLayers dstSubresource;
 754     VkOffset3D dstOffset;
 755     VkExtent3D extent;
 756 } VkImageCopy232;
 757 typedef VkImageCopy232 VkImageCopy2KHR32;
 758
 759 typedef struct VkCopyImageInfo232
 760 {
 761     VkStructureType sType;
 762     PTR32 pNext;
 763     VkImage DECLSPEC_ALIGN(8) srcImage;
 764     VkImageLayout srcImageLayout;
 765     VkImage DECLSPEC_ALIGN(8) dstImage;
 766     VkImageLayout dstImageLayout;
 767     uint32_t regionCount;
 768     PTR32 pRegions;
 769 } VkCopyImageInfo232;
 770 typedef VkCopyImageInfo232 VkCopyImageInfo2KHR32;
 771
 772 typedef struct VkCopyImageToBufferInfo232
 773 {
 774     VkStructureType sType;
 775     PTR32 pNext;
 776     VkImage DECLSPEC_ALIGN(8) srcImage;
 777     VkImageLayout srcImageLayout;
 778     VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
 779     uint32_t regionCount;
 780     PTR32 pRegions;
 781 } VkCopyImageToBufferInfo232;
 782 typedef VkCopyImageToBufferInfo232 VkCopyImageToBufferInfo2KHR32;
 783
 784 typedef struct VkCopyMemoryToAccelerationStructureInfoKHR32
 785 {
 786     VkStructureType sType;
 787     PTR32 pNext;
 788     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src;
 789     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst;
 790     VkCopyAccelerationStructureModeKHR mode;
 791 } VkCopyMemoryToAccelerationStructureInfoKHR32;
 792
 793 typedef struct VkCopyMemoryToMicromapInfoEXT32
 794 {
 795     VkStructureType sType;
 796     PTR32 pNext;
 797     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src;
 798     VkMicromapEXT DECLSPEC_ALIGN(8) dst;
 799     VkCopyMicromapModeEXT mode;
 800 } VkCopyMemoryToMicromapInfoEXT32;
 801
 802 typedef struct VkCopyMicromapInfoEXT32
 803 {
 804     VkStructureType sType;
 805     PTR32 pNext;
 806     VkMicromapEXT DECLSPEC_ALIGN(8) src;
 807     VkMicromapEXT DECLSPEC_ALIGN(8) dst;
 808     VkCopyMicromapModeEXT mode;
 809 } VkCopyMicromapInfoEXT32;
 810
 811 typedef struct VkCopyMicromapToMemoryInfoEXT32
 812 {
 813     VkStructureType sType;
 814     PTR32 pNext;
 815     VkMicromapEXT DECLSPEC_ALIGN(8) src;
 816     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst;
 817     VkCopyMicromapModeEXT mode;
 818 } VkCopyMicromapToMemoryInfoEXT32;
 819
 820 typedef struct VkCuLaunchInfoNVX32
 821 {
 822     VkStructureType sType;
 823     PTR32 pNext;
 824     VkCuFunctionNVX DECLSPEC_ALIGN(8) function;
 825     uint32_t gridDimX;
 826     uint32_t gridDimY;
 827     uint32_t gridDimZ;
 828     uint32_t blockDimX;
 829     uint32_t blockDimY;
 830     uint32_t blockDimZ;
 831     uint32_t sharedMemBytes;
 832     PTR32 paramCount;
 833     PTR32 pParams;
 834     PTR32 extraCount;
 835     PTR32 pExtras;
 836 } VkCuLaunchInfoNVX32;
 837
 838 typedef struct VkDebugMarkerMarkerInfoEXT32
 839 {
 840     VkStructureType sType;
 841     PTR32 pNext;
 842     PTR32 pMarkerName;
 843     float color[4];
 844 } VkDebugMarkerMarkerInfoEXT32;
 845
 846 typedef struct VkDecompressMemoryRegionNV32
 847 {
 848     VkDeviceAddress DECLSPEC_ALIGN(8) srcAddress;
 849     VkDeviceAddress DECLSPEC_ALIGN(8) dstAddress;
 850     VkDeviceSize DECLSPEC_ALIGN(8) compressedSize;
 851     VkDeviceSize DECLSPEC_ALIGN(8) decompressedSize;
 852     VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethod;
 853 } VkDecompressMemoryRegionNV32;
 854
 855 typedef struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM32
 856 {
 857     VkStructureType sType;
 858     PTR32 pNext;
 859     uint32_t fragmentDensityOffsetCount;
 860     PTR32 pFragmentDensityOffsets;
 861 } VkSubpassFragmentDensityMapOffsetEndInfoQCOM32;
 862
 863 typedef struct VkSubpassEndInfo32
 864 {
 865     VkStructureType sType;
 866     PTR32 pNext;
 867 } VkSubpassEndInfo32;
 868 typedef VkSubpassEndInfo32 VkSubpassEndInfoKHR32;
 869
 870 typedef struct VkIndirectCommandsStreamNV32
 871 {
 872     VkBuffer DECLSPEC_ALIGN(8) buffer;
 873     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 874 } VkIndirectCommandsStreamNV32;
 875
 876 typedef struct VkGeneratedCommandsInfoNV32
 877 {
 878     VkStructureType sType;
 879     PTR32 pNext;
 880     VkPipelineBindPoint pipelineBindPoint;
 881     VkPipeline DECLSPEC_ALIGN(8) pipeline;
 882     VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
 883     uint32_t streamCount;
 884     PTR32 pStreams;
 885     uint32_t sequencesCount;
 886     VkBuffer DECLSPEC_ALIGN(8) preprocessBuffer;
 887     VkDeviceSize DECLSPEC_ALIGN(8) preprocessOffset;
 888     VkDeviceSize DECLSPEC_ALIGN(8) preprocessSize;
 889     VkBuffer DECLSPEC_ALIGN(8) sequencesCountBuffer;
 890     VkDeviceSize DECLSPEC_ALIGN(8) sequencesCountOffset;
 891     VkBuffer DECLSPEC_ALIGN(8) sequencesIndexBuffer;
 892     VkDeviceSize DECLSPEC_ALIGN(8) sequencesIndexOffset;
 893 } VkGeneratedCommandsInfoNV32;
 894
 895 typedef struct VkOpticalFlowExecuteInfoNV32
 896 {
 897     VkStructureType sType;
 898     PTR32 pNext;
 899     VkOpticalFlowExecuteFlagsNV flags;
 900     uint32_t regionCount;
 901     PTR32 pRegions;
 902 } VkOpticalFlowExecuteInfoNV32;
 903
 904 typedef struct VkMemoryBarrier32
 905 {
 906     VkStructureType sType;
 907     PTR32 pNext;
 908     VkAccessFlags srcAccessMask;
 909     VkAccessFlags dstAccessMask;
 910 } VkMemoryBarrier32;
 911
 912 typedef struct VkBufferMemoryBarrier32
 913 {
 914     VkStructureType sType;
 915     PTR32 pNext;
 916     VkAccessFlags srcAccessMask;
 917     VkAccessFlags dstAccessMask;
 918     uint32_t srcQueueFamilyIndex;
 919     uint32_t dstQueueFamilyIndex;
 920     VkBuffer DECLSPEC_ALIGN(8) buffer;
 921     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 922     VkDeviceSize DECLSPEC_ALIGN(8) size;
 923 } VkBufferMemoryBarrier32;
 924
 925 typedef struct VkImageMemoryBarrier32
 926 {
 927     VkStructureType sType;
 928     PTR32 pNext;
 929     VkAccessFlags srcAccessMask;
 930     VkAccessFlags dstAccessMask;
 931     VkImageLayout oldLayout;
 932     VkImageLayout newLayout;
 933     uint32_t srcQueueFamilyIndex;
 934     uint32_t dstQueueFamilyIndex;
 935     VkImage DECLSPEC_ALIGN(8) image;
 936     VkImageSubresourceRange subresourceRange;
 937 } VkImageMemoryBarrier32;
 938
 939 typedef struct VkMemoryBarrier232
 940 {
 941     VkStructureType sType;
 942     PTR32 pNext;
 943     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
 944     VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
 945     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
 946     VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
 947 } VkMemoryBarrier232;
 948 typedef VkMemoryBarrier232 VkMemoryBarrier2KHR32;
 949
 950 typedef struct VkBufferMemoryBarrier232
 951 {
 952     VkStructureType sType;
 953     PTR32 pNext;
 954     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
 955     VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
 956     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
 957     VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
 958     uint32_t srcQueueFamilyIndex;
 959     uint32_t dstQueueFamilyIndex;
 960     VkBuffer DECLSPEC_ALIGN(8) buffer;
 961     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 962     VkDeviceSize DECLSPEC_ALIGN(8) size;
 963 } VkBufferMemoryBarrier232;
 964 typedef VkBufferMemoryBarrier232 VkBufferMemoryBarrier2KHR32;
 965
 966 typedef struct VkImageMemoryBarrier232
 967 {
 968     VkStructureType sType;
 969     PTR32 pNext;
 970     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
 971     VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
 972     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
 973     VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
 974     VkImageLayout oldLayout;
 975     VkImageLayout newLayout;
 976     uint32_t srcQueueFamilyIndex;
 977     uint32_t dstQueueFamilyIndex;
 978     VkImage DECLSPEC_ALIGN(8) image;
 979     VkImageSubresourceRange subresourceRange;
 980 } VkImageMemoryBarrier232;
 981 typedef VkImageMemoryBarrier232 VkImageMemoryBarrier2KHR32;
 982
 983 typedef struct VkDependencyInfo32
 984 {
 985     VkStructureType sType;
 986     PTR32 pNext;
 987     VkDependencyFlags dependencyFlags;
 988     uint32_t memoryBarrierCount;
 989     PTR32 pMemoryBarriers;
 990     uint32_t bufferMemoryBarrierCount;
 991     PTR32 pBufferMemoryBarriers;
 992     uint32_t imageMemoryBarrierCount;
 993     PTR32 pImageMemoryBarriers;
 994 } VkDependencyInfo32;
 995 typedef VkDependencyInfo32 VkDependencyInfoKHR32;
 996
 997 typedef struct VkDescriptorImageInfo32
 998 {
 999     VkSampler DECLSPEC_ALIGN(8) sampler;
1000     VkImageView DECLSPEC_ALIGN(8) imageView;
1001     VkImageLayout imageLayout;
1002 } VkDescriptorImageInfo32;
1003
1004 typedef struct VkDescriptorBufferInfo32
1005 {
1006     VkBuffer DECLSPEC_ALIGN(8) buffer;
1007     VkDeviceSize DECLSPEC_ALIGN(8) offset;
1008     VkDeviceSize DECLSPEC_ALIGN(8) range;
1009 } VkDescriptorBufferInfo32;
1010
1011 typedef struct VkWriteDescriptorSetInlineUniformBlock32
1012 {
1013     VkStructureType sType;
1014     PTR32 pNext;
1015     uint32_t dataSize;
1016     PTR32 pData;
1017 } VkWriteDescriptorSetInlineUniformBlock32;
1018 typedef VkWriteDescriptorSetInlineUniformBlock32 VkWriteDescriptorSetInlineUniformBlockEXT32;
1019
1020 typedef struct VkWriteDescriptorSetAccelerationStructureKHR32
1021 {
1022     VkStructureType sType;
1023     PTR32 pNext;
1024     uint32_t accelerationStructureCount;
1025     PTR32 pAccelerationStructures;
1026 } VkWriteDescriptorSetAccelerationStructureKHR32;
1027
1028 typedef struct VkWriteDescriptorSetAccelerationStructureNV32
1029 {
1030     VkStructureType sType;
1031     PTR32 pNext;
1032     uint32_t accelerationStructureCount;
1033     PTR32 pAccelerationStructures;
1034 } VkWriteDescriptorSetAccelerationStructureNV32;
1035
1036 typedef struct VkWriteDescriptorSet32
1037 {
1038     VkStructureType sType;
1039     PTR32 pNext;
1040     VkDescriptorSet DECLSPEC_ALIGN(8) dstSet;
1041     uint32_t dstBinding;
1042     uint32_t dstArrayElement;
1043     uint32_t descriptorCount;
1044     VkDescriptorType descriptorType;
1045     PTR32 pImageInfo;
1046     PTR32 pBufferInfo;
1047     PTR32 pTexelBufferView;
1048 } VkWriteDescriptorSet32;
1049
1050 typedef struct VkImageResolve232
1051 {
1052     VkStructureType sType;
1053     PTR32 pNext;
1054     VkImageSubresourceLayers srcSubresource;
1055     VkOffset3D srcOffset;
1056     VkImageSubresourceLayers dstSubresource;
1057     VkOffset3D dstOffset;
1058     VkExtent3D extent;
1059 } VkImageResolve232;
1060 typedef VkImageResolve232 VkImageResolve2KHR32;
1061
1062 typedef struct VkResolveImageInfo232
1063 {
1064     VkStructureType sType;
1065     PTR32 pNext;
1066     VkImage DECLSPEC_ALIGN(8) srcImage;
1067     VkImageLayout srcImageLayout;
1068     VkImage DECLSPEC_ALIGN(8) dstImage;
1069     VkImageLayout dstImageLayout;
1070     uint32_t regionCount;
1071     PTR32 pRegions;
1072 } VkResolveImageInfo232;
1073 typedef VkResolveImageInfo232 VkResolveImageInfo2KHR32;
1074
1075 typedef struct VkCoarseSampleOrderCustomNV32
1076 {
1077     VkShadingRatePaletteEntryNV shadingRate;
1078     uint32_t sampleCount;
1079     uint32_t sampleLocationCount;
1080     PTR32 pSampleLocations;
1081 } VkCoarseSampleOrderCustomNV32;
1082
1083 typedef struct VkPerformanceMarkerInfoINTEL32
1084 {
1085     VkStructureType sType;
1086     PTR32 pNext;
1087     uint64_t DECLSPEC_ALIGN(8) marker;
1088 } VkPerformanceMarkerInfoINTEL32;
1089
1090 typedef struct VkPerformanceOverrideInfoINTEL32
1091 {
1092     VkStructureType sType;
1093     PTR32 pNext;
1094     VkPerformanceOverrideTypeINTEL type;
1095     VkBool32 enable;
1096     uint64_t DECLSPEC_ALIGN(8) parameter;
1097 } VkPerformanceOverrideInfoINTEL32;
1098
1099 typedef struct VkPerformanceStreamMarkerInfoINTEL32
1100 {
1101     VkStructureType sType;
1102     PTR32 pNext;
1103     uint32_t marker;
1104 } VkPerformanceStreamMarkerInfoINTEL32;
1105
1106 typedef struct VkVertexInputBindingDescription2EXT32
1107 {
1108     VkStructureType sType;
1109     PTR32 pNext;
1110     uint32_t binding;
1111     uint32_t stride;
1112     VkVertexInputRate inputRate;
1113     uint32_t divisor;
1114 } VkVertexInputBindingDescription2EXT32;
1115
1116 typedef struct VkVertexInputAttributeDescription2EXT32
1117 {
1118     VkStructureType sType;
1119     PTR32 pNext;
1120     uint32_t location;
1121     uint32_t binding;
1122     VkFormat format;
1123     uint32_t offset;
1124 } VkVertexInputAttributeDescription2EXT32;
1125
1126 typedef struct VkShadingRatePaletteNV32
1127 {
1128     uint32_t shadingRatePaletteEntryCount;
1129     PTR32 pShadingRatePaletteEntries;
1130 } VkShadingRatePaletteNV32;
1131
1132 typedef struct VkStridedDeviceAddressRegionKHR32
1133 {
1134     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
1135     VkDeviceSize DECLSPEC_ALIGN(8) stride;
1136     VkDeviceSize DECLSPEC_ALIGN(8) size;
1137 } VkStridedDeviceAddressRegionKHR32;
1138
1139 typedef struct VkOpaqueCaptureDescriptorDataCreateInfoEXT32
1140 {
1141     VkStructureType sType;
1142     PTR32 pNext;
1143     PTR32 opaqueCaptureDescriptorData;
1144 } VkOpaqueCaptureDescriptorDataCreateInfoEXT32;
1145
1146 typedef struct VkAccelerationStructureMotionInfoNV32
1147 {
1148     VkStructureType sType;
1149     PTR32 pNext;
1150     uint32_t maxInstances;
1151     VkAccelerationStructureMotionInfoFlagsNV flags;
1152 } VkAccelerationStructureMotionInfoNV32;
1153
1154 typedef struct VkAccelerationStructureCreateInfoKHR32
1155 {
1156     VkStructureType sType;
1157     PTR32 pNext;
1158     VkAccelerationStructureCreateFlagsKHR createFlags;
1159     VkBuffer DECLSPEC_ALIGN(8) buffer;
1160     VkDeviceSize DECLSPEC_ALIGN(8) offset;
1161     VkDeviceSize DECLSPEC_ALIGN(8) size;
1162     VkAccelerationStructureTypeKHR type;
1163     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
1164 } VkAccelerationStructureCreateInfoKHR32;
1165
1166 typedef struct VkAccelerationStructureCreateInfoNV32
1167 {
1168     VkStructureType sType;
1169     PTR32 pNext;
1170     VkDeviceSize DECLSPEC_ALIGN(8) compactedSize;
1171     VkAccelerationStructureInfoNV32 info;
1172 } VkAccelerationStructureCreateInfoNV32;
1173
1174 typedef struct VkDedicatedAllocationBufferCreateInfoNV32
1175 {
1176     VkStructureType sType;
1177     PTR32 pNext;
1178     VkBool32 dedicatedAllocation;
1179 } VkDedicatedAllocationBufferCreateInfoNV32;
1180
1181 typedef struct VkExternalMemoryBufferCreateInfo32
1182 {
1183     VkStructureType sType;
1184     PTR32 pNext;
1185     VkExternalMemoryHandleTypeFlags handleTypes;
1186 } VkExternalMemoryBufferCreateInfo32;
1187 typedef VkExternalMemoryBufferCreateInfo32 VkExternalMemoryBufferCreateInfoKHR32;
1188
1189 typedef struct VkBufferOpaqueCaptureAddressCreateInfo32
1190 {
1191     VkStructureType sType;
1192     PTR32 pNext;
1193     uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress;
1194 } VkBufferOpaqueCaptureAddressCreateInfo32;
1195 typedef VkBufferOpaqueCaptureAddressCreateInfo32 VkBufferOpaqueCaptureAddressCreateInfoKHR32;
1196
1197 typedef struct VkBufferDeviceAddressCreateInfoEXT32
1198 {
1199     VkStructureType sType;
1200     PTR32 pNext;
1201     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
1202 } VkBufferDeviceAddressCreateInfoEXT32;
1203
1204 typedef struct VkBufferCreateInfo32
1205 {
1206     VkStructureType sType;
1207     PTR32 pNext;
1208     VkBufferCreateFlags flags;
1209     VkDeviceSize DECLSPEC_ALIGN(8) size;
1210     VkBufferUsageFlags usage;
1211     VkSharingMode sharingMode;
1212     uint32_t queueFamilyIndexCount;
1213     PTR32 pQueueFamilyIndices;
1214 } VkBufferCreateInfo32;
1215
1216 typedef struct VkBufferViewCreateInfo32
1217 {
1218     VkStructureType sType;
1219     PTR32 pNext;
1220     VkBufferViewCreateFlags flags;
1221     VkBuffer DECLSPEC_ALIGN(8) buffer;
1222     VkFormat format;
1223     VkDeviceSize DECLSPEC_ALIGN(8) offset;
1224     VkDeviceSize DECLSPEC_ALIGN(8) range;
1225 } VkBufferViewCreateInfo32;
1226
1227 typedef struct VkCommandPoolCreateInfo32
1228 {
1229     VkStructureType sType;
1230     PTR32 pNext;
1231     VkCommandPoolCreateFlags flags;
1232     uint32_t queueFamilyIndex;
1233 } VkCommandPoolCreateInfo32;
1234
1235 typedef struct VkPipelineCreationFeedback32
1236 {
1237     VkPipelineCreationFeedbackFlags flags;
1238     uint64_t DECLSPEC_ALIGN(8) duration;
1239 } VkPipelineCreationFeedback32;
1240 typedef VkPipelineCreationFeedback32 VkPipelineCreationFeedbackEXT32;
1241
1242 typedef struct VkSpecializationMapEntry32
1243 {
1244     uint32_t constantID;
1245     uint32_t offset;
1246     PTR32 size;
1247 } VkSpecializationMapEntry32;
1248
1249 typedef struct VkSpecializationInfo32
1250 {
1251     uint32_t mapEntryCount;
1252     PTR32 pMapEntries;
1253     PTR32 dataSize;
1254     PTR32 pData;
1255 } VkSpecializationInfo32;
1256
1257 typedef struct VkShaderModuleCreateInfo32
1258 {
1259     VkStructureType sType;
1260     PTR32 pNext;
1261     VkShaderModuleCreateFlags flags;
1262     PTR32 codeSize;
1263     PTR32 pCode;
1264 } VkShaderModuleCreateInfo32;
1265
1266 typedef struct VkShaderModuleValidationCacheCreateInfoEXT32
1267 {
1268     VkStructureType sType;
1269     PTR32 pNext;
1270     VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
1271 } VkShaderModuleValidationCacheCreateInfoEXT32;
1272
1273 typedef struct VkDebugUtilsObjectNameInfoEXT32
1274 {
1275     VkStructureType sType;
1276     PTR32 pNext;
1277     VkObjectType objectType;
1278     uint64_t DECLSPEC_ALIGN(8) objectHandle;
1279     PTR32 pObjectName;
1280 } VkDebugUtilsObjectNameInfoEXT32;
1281
1282 typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32
1283 {
1284     VkStructureType sType;
1285     PTR32 pNext;
1286     uint32_t requiredSubgroupSize;
1287 } VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32;
1288 typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT32;
1289 typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 VkShaderRequiredSubgroupSizeCreateInfoEXT32;
1290
1291 typedef struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT32
1292 {
1293     VkStructureType sType;
1294     PTR32 pNext;
1295     uint32_t identifierSize;
1296     PTR32 pIdentifier;
1297 } VkPipelineShaderStageModuleIdentifierCreateInfoEXT32;
1298
1299 typedef struct VkPipelineRobustnessCreateInfoEXT32
1300 {
1301     VkStructureType sType;
1302     PTR32 pNext;
1303     VkPipelineRobustnessBufferBehaviorEXT storageBuffers;
1304     VkPipelineRobustnessBufferBehaviorEXT uniformBuffers;
1305     VkPipelineRobustnessBufferBehaviorEXT vertexInputs;
1306     VkPipelineRobustnessImageBehaviorEXT images;
1307 } VkPipelineRobustnessCreateInfoEXT32;
1308
1309 typedef struct VkPipelineShaderStageCreateInfo32
1310 {
1311     VkStructureType sType;
1312     PTR32 pNext;
1313     VkPipelineShaderStageCreateFlags flags;
1314     VkShaderStageFlagBits stage;
1315     VkShaderModule DECLSPEC_ALIGN(8) module;
1316     PTR32 pName;
1317     PTR32 pSpecializationInfo;
1318 } VkPipelineShaderStageCreateInfo32;
1319
1320 typedef struct VkPipelineCreationFeedbackCreateInfo32
1321 {
1322     VkStructureType sType;
1323     PTR32 pNext;
1324     PTR32 pPipelineCreationFeedback;
1325     uint32_t pipelineStageCreationFeedbackCount;
1326     PTR32 pPipelineStageCreationFeedbacks;
1327 } VkPipelineCreationFeedbackCreateInfo32;
1328 typedef VkPipelineCreationFeedbackCreateInfo32 VkPipelineCreationFeedbackCreateInfoEXT32;
1329
1330 typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI32
1331 {
1332     VkStructureType sType;
1333     PTR32 pNext;
1334     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
1335     uint32_t subpass;
1336 } VkSubpassShadingPipelineCreateInfoHUAWEI32;
1337
1338 typedef struct VkPipelineCompilerControlCreateInfoAMD32
1339 {
1340     VkStructureType sType;
1341     PTR32 pNext;
1342     VkPipelineCompilerControlFlagsAMD compilerControlFlags;
1343 } VkPipelineCompilerControlCreateInfoAMD32;
1344
1345 typedef struct VkComputePipelineCreateInfo32
1346 {
1347     VkStructureType sType;
1348     PTR32 pNext;
1349     VkPipelineCreateFlags flags;
1350     VkPipelineShaderStageCreateInfo32 DECLSPEC_ALIGN(8) stage;
1351     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
1352     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
1353     int32_t basePipelineIndex;
1354 } VkComputePipelineCreateInfo32;
1355
1356 typedef struct VkCuFunctionCreateInfoNVX32
1357 {
1358     VkStructureType sType;
1359     PTR32 pNext;
1360     VkCuModuleNVX DECLSPEC_ALIGN(8) module;
1361     PTR32 pName;
1362 } VkCuFunctionCreateInfoNVX32;
1363
1364 typedef struct VkCuModuleCreateInfoNVX32
1365 {
1366     VkStructureType sType;
1367     PTR32 pNext;
1368     PTR32 dataSize;
1369     PTR32 pData;
1370 } VkCuModuleCreateInfoNVX32;
1371
1372 typedef struct VkDebugReportCallbackCreateInfoEXT32
1373 {
1374     VkStructureType sType;
1375     PTR32 pNext;
1376     VkDebugReportFlagsEXT flags;
1377     PFN_vkDebugReportCallbackEXT pfnCallback;
1378     PTR32 pUserData;
1379 } VkDebugReportCallbackCreateInfoEXT32;
1380
1381 typedef struct VkDebugUtilsMessengerCreateInfoEXT32
1382 {
1383     VkStructureType sType;
1384     PTR32 pNext;
1385     VkDebugUtilsMessengerCreateFlagsEXT flags;
1386     VkDebugUtilsMessageSeverityFlagsEXT messageSeverity;
1387     VkDebugUtilsMessageTypeFlagsEXT messageType;
1388     PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback;
1389     PTR32 pUserData;
1390 } VkDebugUtilsMessengerCreateInfoEXT32;
1391
1392 typedef struct VkMutableDescriptorTypeListEXT32
1393 {
1394     uint32_t descriptorTypeCount;
1395     PTR32 pDescriptorTypes;
1396 } VkMutableDescriptorTypeListEXT32;
1397 typedef VkMutableDescriptorTypeListEXT32 VkMutableDescriptorTypeListVALVE32;
1398
1399 typedef struct VkDescriptorPoolInlineUniformBlockCreateInfo32
1400 {
1401     VkStructureType sType;
1402     PTR32 pNext;
1403     uint32_t maxInlineUniformBlockBindings;
1404 } VkDescriptorPoolInlineUniformBlockCreateInfo32;
1405 typedef VkDescriptorPoolInlineUniformBlockCreateInfo32 VkDescriptorPoolInlineUniformBlockCreateInfoEXT32;
1406
1407 typedef struct VkMutableDescriptorTypeCreateInfoEXT32
1408 {
1409     VkStructureType sType;
1410     PTR32 pNext;
1411     uint32_t mutableDescriptorTypeListCount;
1412     PTR32 pMutableDescriptorTypeLists;
1413 } VkMutableDescriptorTypeCreateInfoEXT32;
1414 typedef VkMutableDescriptorTypeCreateInfoEXT32 VkMutableDescriptorTypeCreateInfoVALVE32;
1415
1416 typedef struct VkDescriptorPoolCreateInfo32
1417 {
1418     VkStructureType sType;
1419     PTR32 pNext;
1420     VkDescriptorPoolCreateFlags flags;
1421     uint32_t maxSets;
1422     uint32_t poolSizeCount;
1423     PTR32 pPoolSizes;
1424 } VkDescriptorPoolCreateInfo32;
1425
1426 typedef struct VkDescriptorSetLayoutBinding32
1427 {
1428     uint32_t binding;
1429     VkDescriptorType descriptorType;
1430     uint32_t descriptorCount;
1431     VkShaderStageFlags stageFlags;
1432     PTR32 pImmutableSamplers;
1433 } VkDescriptorSetLayoutBinding32;
1434
1435 typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo32
1436 {
1437     VkStructureType sType;
1438     PTR32 pNext;
1439     uint32_t bindingCount;
1440     PTR32 pBindingFlags;
1441 } VkDescriptorSetLayoutBindingFlagsCreateInfo32;
1442 typedef VkDescriptorSetLayoutBindingFlagsCreateInfo32 VkDescriptorSetLayoutBindingFlagsCreateInfoEXT32;
1443
1444 typedef struct VkDescriptorSetLayoutCreateInfo32
1445 {
1446     VkStructureType sType;
1447     PTR32 pNext;
1448     VkDescriptorSetLayoutCreateFlags flags;
1449     uint32_t bindingCount;
1450     PTR32 pBindings;
1451 } VkDescriptorSetLayoutCreateInfo32;
1452
1453 typedef struct VkDescriptorUpdateTemplateEntry32
1454 {
1455     uint32_t dstBinding;
1456     uint32_t dstArrayElement;
1457     uint32_t descriptorCount;
1458     VkDescriptorType descriptorType;
1459     PTR32 offset;
1460     PTR32 stride;
1461 } VkDescriptorUpdateTemplateEntry32;
1462 typedef VkDescriptorUpdateTemplateEntry32 VkDescriptorUpdateTemplateEntryKHR32;
1463
1464 typedef struct VkDescriptorUpdateTemplateCreateInfo32
1465 {
1466     VkStructureType sType;
1467     PTR32 pNext;
1468     VkDescriptorUpdateTemplateCreateFlags flags;
1469     uint32_t descriptorUpdateEntryCount;
1470     PTR32 pDescriptorUpdateEntries;
1471     VkDescriptorUpdateTemplateType templateType;
1472     VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
1473     VkPipelineBindPoint pipelineBindPoint;
1474     VkPipelineLayout DECLSPEC_ALIGN(8) pipelineLayout;
1475     uint32_t set;
1476 } VkDescriptorUpdateTemplateCreateInfo32;
1477 typedef VkDescriptorUpdateTemplateCreateInfo32 VkDescriptorUpdateTemplateCreateInfoKHR32;
1478
1479 typedef struct VkDeviceQueueGlobalPriorityCreateInfoKHR32
1480 {
1481     VkStructureType sType;
1482     PTR32 pNext;
1483     VkQueueGlobalPriorityKHR globalPriority;
1484 } VkDeviceQueueGlobalPriorityCreateInfoKHR32;
1485 typedef VkDeviceQueueGlobalPriorityCreateInfoKHR32 VkDeviceQueueGlobalPriorityCreateInfoEXT32;
1486
1487 typedef struct VkDeviceQueueCreateInfo32
1488 {
1489     VkStructureType sType;
1490     PTR32 pNext;
1491     VkDeviceQueueCreateFlags flags;
1492     uint32_t queueFamilyIndex;
1493     uint32_t queueCount;
1494     PTR32 pQueuePriorities;
1495 } VkDeviceQueueCreateInfo32;
1496
1497 typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32
1498 {
1499     VkStructureType sType;
1500     PTR32 pNext;
1501     VkBool32 deviceGeneratedCommands;
1502 } VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32;
1503
1504 typedef struct VkDevicePrivateDataCreateInfo32
1505 {
1506     VkStructureType sType;
1507     PTR32 pNext;
1508     uint32_t privateDataSlotRequestCount;
1509 } VkDevicePrivateDataCreateInfo32;
1510 typedef VkDevicePrivateDataCreateInfo32 VkDevicePrivateDataCreateInfoEXT32;
1511
1512 typedef struct VkPhysicalDevicePrivateDataFeatures32
1513 {
1514     VkStructureType sType;
1515     PTR32 pNext;
1516     VkBool32 privateData;
1517 } VkPhysicalDevicePrivateDataFeatures32;
1518 typedef VkPhysicalDevicePrivateDataFeatures32 VkPhysicalDevicePrivateDataFeaturesEXT32;
1519
1520 typedef struct VkPhysicalDeviceFeatures232
1521 {
1522     VkStructureType sType;
1523     PTR32 pNext;
1524     VkPhysicalDeviceFeatures features;
1525 } VkPhysicalDeviceFeatures232;
1526 typedef VkPhysicalDeviceFeatures232 VkPhysicalDeviceFeatures2KHR32;
1527
1528 typedef struct VkPhysicalDeviceVariablePointersFeatures32
1529 {
1530     VkStructureType sType;
1531     PTR32 pNext;
1532     VkBool32 variablePointersStorageBuffer;
1533     VkBool32 variablePointers;
1534 } VkPhysicalDeviceVariablePointersFeatures32;
1535 typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointersFeaturesKHR32;
1536 typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointerFeaturesKHR32;
1537 typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointerFeatures32;
1538
1539 typedef struct VkPhysicalDeviceMultiviewFeatures32
1540 {
1541     VkStructureType sType;
1542     PTR32 pNext;
1543     VkBool32 multiview;
1544     VkBool32 multiviewGeometryShader;
1545     VkBool32 multiviewTessellationShader;
1546 } VkPhysicalDeviceMultiviewFeatures32;
1547 typedef VkPhysicalDeviceMultiviewFeatures32 VkPhysicalDeviceMultiviewFeaturesKHR32;
1548
1549 typedef struct VkDeviceGroupDeviceCreateInfo32
1550 {
1551     VkStructureType sType;
1552     PTR32 pNext;
1553     uint32_t physicalDeviceCount;
1554     PTR32 pPhysicalDevices;
1555 } VkDeviceGroupDeviceCreateInfo32;
1556 typedef VkDeviceGroupDeviceCreateInfo32 VkDeviceGroupDeviceCreateInfoKHR32;
1557
1558 typedef struct VkPhysicalDevicePresentIdFeaturesKHR32
1559 {
1560     VkStructureType sType;
1561     PTR32 pNext;
1562     VkBool32 presentId;
1563 } VkPhysicalDevicePresentIdFeaturesKHR32;
1564
1565 typedef struct VkPhysicalDevicePresentWaitFeaturesKHR32
1566 {
1567     VkStructureType sType;
1568     PTR32 pNext;
1569     VkBool32 presentWait;
1570 } VkPhysicalDevicePresentWaitFeaturesKHR32;
1571
1572 typedef struct VkPhysicalDevice16BitStorageFeatures32
1573 {
1574     VkStructureType sType;
1575     PTR32 pNext;
1576     VkBool32 storageBuffer16BitAccess;
1577     VkBool32 uniformAndStorageBuffer16BitAccess;
1578     VkBool32 storagePushConstant16;
1579     VkBool32 storageInputOutput16;
1580 } VkPhysicalDevice16BitStorageFeatures32;
1581 typedef VkPhysicalDevice16BitStorageFeatures32 VkPhysicalDevice16BitStorageFeaturesKHR32;
1582
1583 typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32
1584 {
1585     VkStructureType sType;
1586     PTR32 pNext;
1587     VkBool32 shaderSubgroupExtendedTypes;
1588 } VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32;
1589 typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR32;
1590
1591 typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures32
1592 {
1593     VkStructureType sType;
1594     PTR32 pNext;
1595     VkBool32 samplerYcbcrConversion;
1596 } VkPhysicalDeviceSamplerYcbcrConversionFeatures32;
1597 typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures32 VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR32;
1598
1599 typedef struct VkPhysicalDeviceProtectedMemoryFeatures32
1600 {
1601     VkStructureType sType;
1602     PTR32 pNext;
1603     VkBool32 protectedMemory;
1604 } VkPhysicalDeviceProtectedMemoryFeatures32;
1605
1606 typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32
1607 {
1608     VkStructureType sType;
1609     PTR32 pNext;
1610     VkBool32 advancedBlendCoherentOperations;
1611 } VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32;
1612
1613 typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT32
1614 {
1615     VkStructureType sType;
1616     PTR32 pNext;
1617     VkBool32 multiDraw;
1618 } VkPhysicalDeviceMultiDrawFeaturesEXT32;
1619
1620 typedef struct VkPhysicalDeviceInlineUniformBlockFeatures32
1621 {
1622     VkStructureType sType;
1623     PTR32 pNext;
1624     VkBool32 inlineUniformBlock;
1625     VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
1626 } VkPhysicalDeviceInlineUniformBlockFeatures32;
1627 typedef VkPhysicalDeviceInlineUniformBlockFeatures32 VkPhysicalDeviceInlineUniformBlockFeaturesEXT32;
1628
1629 typedef struct VkPhysicalDeviceMaintenance4Features32
1630 {
1631     VkStructureType sType;
1632     PTR32 pNext;
1633     VkBool32 maintenance4;
1634 } VkPhysicalDeviceMaintenance4Features32;
1635 typedef VkPhysicalDeviceMaintenance4Features32 VkPhysicalDeviceMaintenance4FeaturesKHR32;
1636
1637 typedef struct VkPhysicalDeviceShaderDrawParametersFeatures32
1638 {
1639     VkStructureType sType;
1640     PTR32 pNext;
1641     VkBool32 shaderDrawParameters;
1642 } VkPhysicalDeviceShaderDrawParametersFeatures32;
1643 typedef VkPhysicalDeviceShaderDrawParametersFeatures32 VkPhysicalDeviceShaderDrawParameterFeatures32;
1644
1645 typedef struct VkPhysicalDeviceShaderFloat16Int8Features32
1646 {
1647     VkStructureType sType;
1648     PTR32 pNext;
1649     VkBool32 shaderFloat16;
1650     VkBool32 shaderInt8;
1651 } VkPhysicalDeviceShaderFloat16Int8Features32;
1652 typedef VkPhysicalDeviceShaderFloat16Int8Features32 VkPhysicalDeviceShaderFloat16Int8FeaturesKHR32;
1653 typedef VkPhysicalDeviceShaderFloat16Int8Features32 VkPhysicalDeviceFloat16Int8FeaturesKHR32;
1654
1655 typedef struct VkPhysicalDeviceHostQueryResetFeatures32
1656 {
1657     VkStructureType sType;
1658     PTR32 pNext;
1659     VkBool32 hostQueryReset;
1660 } VkPhysicalDeviceHostQueryResetFeatures32;
1661 typedef VkPhysicalDeviceHostQueryResetFeatures32 VkPhysicalDeviceHostQueryResetFeaturesEXT32;
1662
1663 typedef struct VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32
1664 {
1665     VkStructureType sType;
1666     PTR32 pNext;
1667     VkBool32 globalPriorityQuery;
1668 } VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32;
1669 typedef VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT32;
1670
1671 typedef struct VkPhysicalDeviceDescriptorIndexingFeatures32
1672 {
1673     VkStructureType sType;
1674     PTR32 pNext;
1675     VkBool32 shaderInputAttachmentArrayDynamicIndexing;
1676     VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;
1677     VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;
1678     VkBool32 shaderUniformBufferArrayNonUniformIndexing;
1679     VkBool32 shaderSampledImageArrayNonUniformIndexing;
1680     VkBool32 shaderStorageBufferArrayNonUniformIndexing;
1681     VkBool32 shaderStorageImageArrayNonUniformIndexing;
1682     VkBool32 shaderInputAttachmentArrayNonUniformIndexing;
1683     VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;
1684     VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;
1685     VkBool32 descriptorBindingUniformBufferUpdateAfterBind;
1686     VkBool32 descriptorBindingSampledImageUpdateAfterBind;
1687     VkBool32 descriptorBindingStorageImageUpdateAfterBind;
1688     VkBool32 descriptorBindingStorageBufferUpdateAfterBind;
1689     VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
1690     VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
1691     VkBool32 descriptorBindingUpdateUnusedWhilePending;
1692     VkBool32 descriptorBindingPartiallyBound;
1693     VkBool32 descriptorBindingVariableDescriptorCount;
1694     VkBool32 runtimeDescriptorArray;
1695 } VkPhysicalDeviceDescriptorIndexingFeatures32;
1696 typedef VkPhysicalDeviceDescriptorIndexingFeatures32 VkPhysicalDeviceDescriptorIndexingFeaturesEXT32;
1697
1698 typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures32
1699 {
1700     VkStructureType sType;
1701     PTR32 pNext;
1702     VkBool32 timelineSemaphore;
1703 } VkPhysicalDeviceTimelineSemaphoreFeatures32;
1704 typedef VkPhysicalDeviceTimelineSemaphoreFeatures32 VkPhysicalDeviceTimelineSemaphoreFeaturesKHR32;
1705
1706 typedef struct VkPhysicalDevice8BitStorageFeatures32
1707 {
1708     VkStructureType sType;
1709     PTR32 pNext;
1710     VkBool32 storageBuffer8BitAccess;
1711     VkBool32 uniformAndStorageBuffer8BitAccess;
1712     VkBool32 storagePushConstant8;
1713 } VkPhysicalDevice8BitStorageFeatures32;
1714 typedef VkPhysicalDevice8BitStorageFeatures32 VkPhysicalDevice8BitStorageFeaturesKHR32;
1715
1716 typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT32
1717 {
1718     VkStructureType sType;
1719     PTR32 pNext;
1720     VkBool32 conditionalRendering;
1721     VkBool32 inheritedConditionalRendering;
1722 } VkPhysicalDeviceConditionalRenderingFeaturesEXT32;
1723
1724 typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures32
1725 {
1726     VkStructureType sType;
1727     PTR32 pNext;
1728     VkBool32 vulkanMemoryModel;
1729     VkBool32 vulkanMemoryModelDeviceScope;
1730     VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
1731 } VkPhysicalDeviceVulkanMemoryModelFeatures32;
1732 typedef VkPhysicalDeviceVulkanMemoryModelFeatures32 VkPhysicalDeviceVulkanMemoryModelFeaturesKHR32;
1733
1734 typedef struct VkPhysicalDeviceShaderAtomicInt64Features32
1735 {
1736     VkStructureType sType;
1737     PTR32 pNext;
1738     VkBool32 shaderBufferInt64Atomics;
1739     VkBool32 shaderSharedInt64Atomics;
1740 } VkPhysicalDeviceShaderAtomicInt64Features32;
1741 typedef VkPhysicalDeviceShaderAtomicInt64Features32 VkPhysicalDeviceShaderAtomicInt64FeaturesKHR32;
1742
1743 typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32
1744 {
1745     VkStructureType sType;
1746     PTR32 pNext;
1747     VkBool32 shaderBufferFloat32Atomics;
1748     VkBool32 shaderBufferFloat32AtomicAdd;
1749     VkBool32 shaderBufferFloat64Atomics;
1750     VkBool32 shaderBufferFloat64AtomicAdd;
1751     VkBool32 shaderSharedFloat32Atomics;
1752     VkBool32 shaderSharedFloat32AtomicAdd;
1753     VkBool32 shaderSharedFloat64Atomics;
1754     VkBool32 shaderSharedFloat64AtomicAdd;
1755     VkBool32 shaderImageFloat32Atomics;
1756     VkBool32 shaderImageFloat32AtomicAdd;
1757     VkBool32 sparseImageFloat32Atomics;
1758     VkBool32 sparseImageFloat32AtomicAdd;
1759 } VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32;
1760
1761 typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32
1762 {
1763     VkStructureType sType;
1764     PTR32 pNext;
1765     VkBool32 shaderBufferFloat16Atomics;
1766     VkBool32 shaderBufferFloat16AtomicAdd;
1767     VkBool32 shaderBufferFloat16AtomicMinMax;
1768     VkBool32 shaderBufferFloat32AtomicMinMax;
1769     VkBool32 shaderBufferFloat64AtomicMinMax;
1770     VkBool32 shaderSharedFloat16Atomics;
1771     VkBool32 shaderSharedFloat16AtomicAdd;
1772     VkBool32 shaderSharedFloat16AtomicMinMax;
1773     VkBool32 shaderSharedFloat32AtomicMinMax;
1774     VkBool32 shaderSharedFloat64AtomicMinMax;
1775     VkBool32 shaderImageFloat32AtomicMinMax;
1776     VkBool32 sparseImageFloat32AtomicMinMax;
1777 } VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32;
1778
1779 typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32
1780 {
1781     VkStructureType sType;
1782     PTR32 pNext;
1783     VkBool32 vertexAttributeInstanceRateDivisor;
1784     VkBool32 vertexAttributeInstanceRateZeroDivisor;
1785 } VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32;
1786
1787 typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT32
1788 {
1789     VkStructureType sType;
1790     PTR32 pNext;
1791     VkBool32 decodeModeSharedExponent;
1792 } VkPhysicalDeviceASTCDecodeFeaturesEXT32;
1793
1794 typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT32
1795 {
1796     VkStructureType sType;
1797     PTR32 pNext;
1798     VkBool32 transformFeedback;
1799     VkBool32 geometryStreams;
1800 } VkPhysicalDeviceTransformFeedbackFeaturesEXT32;
1801
1802 typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32
1803 {
1804     VkStructureType sType;
1805     PTR32 pNext;
1806     VkBool32 representativeFragmentTest;
1807 } VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32;
1808
1809 typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV32
1810 {
1811     VkStructureType sType;
1812     PTR32 pNext;
1813     VkBool32 exclusiveScissor;
1814 } VkPhysicalDeviceExclusiveScissorFeaturesNV32;
1815
1816 typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV32
1817 {
1818     VkStructureType sType;
1819     PTR32 pNext;
1820     VkBool32 cornerSampledImage;
1821 } VkPhysicalDeviceCornerSampledImageFeaturesNV32;
1822
1823 typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32
1824 {
1825     VkStructureType sType;
1826     PTR32 pNext;
1827     VkBool32 computeDerivativeGroupQuads;
1828     VkBool32 computeDerivativeGroupLinear;
1829 } VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32;
1830
1831 typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV32
1832 {
1833     VkStructureType sType;
1834     PTR32 pNext;
1835     VkBool32 imageFootprint;
1836 } VkPhysicalDeviceShaderImageFootprintFeaturesNV32;
1837
1838 typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32
1839 {
1840     VkStructureType sType;
1841     PTR32 pNext;
1842     VkBool32 dedicatedAllocationImageAliasing;
1843 } VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32;
1844
1845 typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32
1846 {
1847     VkStructureType sType;
1848     PTR32 pNext;
1849     VkBool32 indirectCopy;
1850 } VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32;
1851
1852 typedef struct VkPhysicalDeviceMemoryDecompressionFeaturesNV32
1853 {
1854     VkStructureType sType;
1855     PTR32 pNext;
1856     VkBool32 memoryDecompression;
1857 } VkPhysicalDeviceMemoryDecompressionFeaturesNV32;
1858
1859 typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV32
1860 {
1861     VkStructureType sType;
1862     PTR32 pNext;
1863     VkBool32 shadingRateImage;
1864     VkBool32 shadingRateCoarseSampleOrder;
1865 } VkPhysicalDeviceShadingRateImageFeaturesNV32;
1866
1867 typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32
1868 {
1869     VkStructureType sType;
1870     PTR32 pNext;
1871     VkBool32 invocationMask;
1872 } VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32;
1873
1874 typedef struct VkPhysicalDeviceMeshShaderFeaturesNV32
1875 {
1876     VkStructureType sType;
1877     PTR32 pNext;
1878     VkBool32 taskShader;
1879     VkBool32 meshShader;
1880 } VkPhysicalDeviceMeshShaderFeaturesNV32;
1881
1882 typedef struct VkPhysicalDeviceMeshShaderFeaturesEXT32
1883 {
1884     VkStructureType sType;
1885     PTR32 pNext;
1886     VkBool32 taskShader;
1887     VkBool32 meshShader;
1888     VkBool32 multiviewMeshShader;
1889     VkBool32 primitiveFragmentShadingRateMeshShader;
1890     VkBool32 meshShaderQueries;
1891 } VkPhysicalDeviceMeshShaderFeaturesEXT32;
1892
1893 typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR32
1894 {
1895     VkStructureType sType;
1896     PTR32 pNext;
1897     VkBool32 accelerationStructure;
1898     VkBool32 accelerationStructureCaptureReplay;
1899     VkBool32 accelerationStructureIndirectBuild;
1900     VkBool32 accelerationStructureHostCommands;
1901     VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind;
1902 } VkPhysicalDeviceAccelerationStructureFeaturesKHR32;
1903
1904 typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR32
1905 {
1906     VkStructureType sType;
1907     PTR32 pNext;
1908     VkBool32 rayTracingPipeline;
1909     VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay;
1910     VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
1911     VkBool32 rayTracingPipelineTraceRaysIndirect;
1912     VkBool32 rayTraversalPrimitiveCulling;
1913 } VkPhysicalDeviceRayTracingPipelineFeaturesKHR32;
1914
1915 typedef struct VkPhysicalDeviceRayQueryFeaturesKHR32
1916 {
1917     VkStructureType sType;
1918     PTR32 pNext;
1919     VkBool32 rayQuery;
1920 } VkPhysicalDeviceRayQueryFeaturesKHR32;
1921
1922 typedef struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32
1923 {
1924     VkStructureType sType;
1925     PTR32 pNext;
1926     VkBool32 rayTracingMaintenance1;
1927     VkBool32 rayTracingPipelineTraceRaysIndirect2;
1928 } VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32;
1929
1930 typedef struct VkDeviceMemoryOverallocationCreateInfoAMD32
1931 {
1932     VkStructureType sType;
1933     PTR32 pNext;
1934     VkMemoryOverallocationBehaviorAMD overallocationBehavior;
1935 } VkDeviceMemoryOverallocationCreateInfoAMD32;
1936
1937 typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT32
1938 {
1939     VkStructureType sType;
1940     PTR32 pNext;
1941     VkBool32 fragmentDensityMap;
1942     VkBool32 fragmentDensityMapDynamic;
1943     VkBool32 fragmentDensityMapNonSubsampledImages;
1944 } VkPhysicalDeviceFragmentDensityMapFeaturesEXT32;
1945
1946 typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32
1947 {
1948     VkStructureType sType;
1949     PTR32 pNext;
1950     VkBool32 fragmentDensityMapDeferred;
1951 } VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32;
1952
1953 typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32
1954 {
1955     VkStructureType sType;
1956     PTR32 pNext;
1957     VkBool32 fragmentDensityMapOffset;
1958 } VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32;
1959
1960 typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures32
1961 {
1962     VkStructureType sType;
1963     PTR32 pNext;
1964     VkBool32 scalarBlockLayout;
1965 } VkPhysicalDeviceScalarBlockLayoutFeatures32;
1966 typedef VkPhysicalDeviceScalarBlockLayoutFeatures32 VkPhysicalDeviceScalarBlockLayoutFeaturesEXT32;
1967
1968 typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures32
1969 {
1970     VkStructureType sType;
1971     PTR32 pNext;
1972     VkBool32 uniformBufferStandardLayout;
1973 } VkPhysicalDeviceUniformBufferStandardLayoutFeatures32;
1974 typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR32;
1975
1976 typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT32
1977 {
1978     VkStructureType sType;
1979     PTR32 pNext;
1980     VkBool32 depthClipEnable;
1981 } VkPhysicalDeviceDepthClipEnableFeaturesEXT32;
1982
1983 typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT32
1984 {
1985     VkStructureType sType;
1986     PTR32 pNext;
1987     VkBool32 memoryPriority;
1988 } VkPhysicalDeviceMemoryPriorityFeaturesEXT32;
1989
1990 typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32
1991 {
1992     VkStructureType sType;
1993     PTR32 pNext;
1994     VkBool32 pageableDeviceLocalMemory;
1995 } VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32;
1996
1997 typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures32
1998 {
1999     VkStructureType sType;
2000     PTR32 pNext;
2001     VkBool32 bufferDeviceAddress;
2002     VkBool32 bufferDeviceAddressCaptureReplay;
2003     VkBool32 bufferDeviceAddressMultiDevice;
2004 } VkPhysicalDeviceBufferDeviceAddressFeatures32;
2005 typedef VkPhysicalDeviceBufferDeviceAddressFeatures32 VkPhysicalDeviceBufferDeviceAddressFeaturesKHR32;
2006
2007 typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32
2008 {
2009     VkStructureType sType;
2010     PTR32 pNext;
2011     VkBool32 bufferDeviceAddress;
2012     VkBool32 bufferDeviceAddressCaptureReplay;
2013     VkBool32 bufferDeviceAddressMultiDevice;
2014 } VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32;
2015 typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 VkPhysicalDeviceBufferAddressFeaturesEXT32;
2016
2017 typedef struct VkPhysicalDeviceImagelessFramebufferFeatures32
2018 {
2019     VkStructureType sType;
2020     PTR32 pNext;
2021     VkBool32 imagelessFramebuffer;
2022 } VkPhysicalDeviceImagelessFramebufferFeatures32;
2023 typedef VkPhysicalDeviceImagelessFramebufferFeatures32 VkPhysicalDeviceImagelessFramebufferFeaturesKHR32;
2024
2025 typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures32
2026 {
2027     VkStructureType sType;
2028     PTR32 pNext;
2029     VkBool32 textureCompressionASTC_HDR;
2030 } VkPhysicalDeviceTextureCompressionASTCHDRFeatures32;
2031 typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT32;
2032
2033 typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV32
2034 {
2035     VkStructureType sType;
2036     PTR32 pNext;
2037     VkBool32 cooperativeMatrix;
2038     VkBool32 cooperativeMatrixRobustBufferAccess;
2039 } VkPhysicalDeviceCooperativeMatrixFeaturesNV32;
2040
2041 typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32
2042 {
2043     VkStructureType sType;
2044     PTR32 pNext;
2045     VkBool32 ycbcrImageArrays;
2046 } VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32;
2047
2048 typedef struct VkPhysicalDevicePresentBarrierFeaturesNV32
2049 {
2050     VkStructureType sType;
2051     PTR32 pNext;
2052     VkBool32 presentBarrier;
2053 } VkPhysicalDevicePresentBarrierFeaturesNV32;
2054
2055 typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR32
2056 {
2057     VkStructureType sType;
2058     PTR32 pNext;
2059     VkBool32 performanceCounterQueryPools;
2060     VkBool32 performanceCounterMultipleQueryPools;
2061 } VkPhysicalDevicePerformanceQueryFeaturesKHR32;
2062
2063 typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV32
2064 {
2065     VkStructureType sType;
2066     PTR32 pNext;
2067     VkBool32 coverageReductionMode;
2068 } VkPhysicalDeviceCoverageReductionModeFeaturesNV32;
2069
2070 typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32
2071 {
2072     VkStructureType sType;
2073     PTR32 pNext;
2074     VkBool32 shaderIntegerFunctions2;
2075 } VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32;
2076
2077 typedef struct VkPhysicalDeviceShaderClockFeaturesKHR32
2078 {
2079     VkStructureType sType;
2080     PTR32 pNext;
2081     VkBool32 shaderSubgroupClock;
2082     VkBool32 shaderDeviceClock;
2083 } VkPhysicalDeviceShaderClockFeaturesKHR32;
2084
2085 typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT32
2086 {
2087     VkStructureType sType;
2088     PTR32 pNext;
2089     VkBool32 indexTypeUint8;
2090 } VkPhysicalDeviceIndexTypeUint8FeaturesEXT32;
2091
2092 typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32
2093 {
2094     VkStructureType sType;
2095     PTR32 pNext;
2096     VkBool32 shaderSMBuiltins;
2097 } VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32;
2098
2099 typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32
2100 {
2101     VkStructureType sType;
2102     PTR32 pNext;
2103     VkBool32 fragmentShaderSampleInterlock;
2104     VkBool32 fragmentShaderPixelInterlock;
2105     VkBool32 fragmentShaderShadingRateInterlock;
2106 } VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32;
2107
2108 typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32
2109 {
2110     VkStructureType sType;
2111     PTR32 pNext;
2112     VkBool32 separateDepthStencilLayouts;
2113 } VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32;
2114 typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR32;
2115
2116 typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32
2117 {
2118     VkStructureType sType;
2119     PTR32 pNext;
2120     VkBool32 primitiveTopologyListRestart;
2121     VkBool32 primitiveTopologyPatchListRestart;
2122 } VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32;
2123
2124 typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32
2125 {
2126     VkStructureType sType;
2127     PTR32 pNext;
2128     VkBool32 pipelineExecutableInfo;
2129 } VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32;
2130
2131 typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32
2132 {
2133     VkStructureType sType;
2134     PTR32 pNext;
2135     VkBool32 shaderDemoteToHelperInvocation;
2136 } VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32;
2137 typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT32;
2138
2139 typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32
2140 {
2141     VkStructureType sType;
2142     PTR32 pNext;
2143     VkBool32 texelBufferAlignment;
2144 } VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32;
2145
2146 typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures32
2147 {
2148     VkStructureType sType;
2149     PTR32 pNext;
2150     VkBool32 subgroupSizeControl;
2151     VkBool32 computeFullSubgroups;
2152 } VkPhysicalDeviceSubgroupSizeControlFeatures32;
2153 typedef VkPhysicalDeviceSubgroupSizeControlFeatures32 VkPhysicalDeviceSubgroupSizeControlFeaturesEXT32;
2154
2155 typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT32
2156 {
2157     VkStructureType sType;
2158     PTR32 pNext;
2159     VkBool32 rectangularLines;
2160     VkBool32 bresenhamLines;
2161     VkBool32 smoothLines;
2162     VkBool32 stippledRectangularLines;
2163     VkBool32 stippledBresenhamLines;
2164     VkBool32 stippledSmoothLines;
2165 } VkPhysicalDeviceLineRasterizationFeaturesEXT32;
2166
2167 typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures32
2168 {
2169     VkStructureType sType;
2170     PTR32 pNext;
2171     VkBool32 pipelineCreationCacheControl;
2172 } VkPhysicalDevicePipelineCreationCacheControlFeatures32;
2173 typedef VkPhysicalDevicePipelineCreationCacheControlFeatures32 VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT32;
2174
2175 typedef struct VkPhysicalDeviceVulkan11Features32
2176 {
2177     VkStructureType sType;
2178     PTR32 pNext;
2179     VkBool32 storageBuffer16BitAccess;
2180     VkBool32 uniformAndStorageBuffer16BitAccess;
2181     VkBool32 storagePushConstant16;
2182     VkBool32 storageInputOutput16;
2183     VkBool32 multiview;
2184     VkBool32 multiviewGeometryShader;
2185     VkBool32 multiviewTessellationShader;
2186     VkBool32 variablePointersStorageBuffer;
2187     VkBool32 variablePointers;
2188     VkBool32 protectedMemory;
2189     VkBool32 samplerYcbcrConversion;
2190     VkBool32 shaderDrawParameters;
2191 } VkPhysicalDeviceVulkan11Features32;
2192
2193 typedef struct VkPhysicalDeviceVulkan12Features32
2194 {
2195     VkStructureType sType;
2196     PTR32 pNext;
2197     VkBool32 samplerMirrorClampToEdge;
2198     VkBool32 drawIndirectCount;
2199     VkBool32 storageBuffer8BitAccess;
2200     VkBool32 uniformAndStorageBuffer8BitAccess;
2201     VkBool32 storagePushConstant8;
2202     VkBool32 shaderBufferInt64Atomics;
2203     VkBool32 shaderSharedInt64Atomics;
2204     VkBool32 shaderFloat16;
2205     VkBool32 shaderInt8;
2206     VkBool32 descriptorIndexing;
2207     VkBool32 shaderInputAttachmentArrayDynamicIndexing;
2208     VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;
2209     VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;
2210     VkBool32 shaderUniformBufferArrayNonUniformIndexing;
2211     VkBool32 shaderSampledImageArrayNonUniformIndexing;
2212     VkBool32 shaderStorageBufferArrayNonUniformIndexing;
2213     VkBool32 shaderStorageImageArrayNonUniformIndexing;
2214     VkBool32 shaderInputAttachmentArrayNonUniformIndexing;
2215     VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;
2216     VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;
2217     VkBool32 descriptorBindingUniformBufferUpdateAfterBind;
2218     VkBool32 descriptorBindingSampledImageUpdateAfterBind;
2219     VkBool32 descriptorBindingStorageImageUpdateAfterBind;
2220     VkBool32 descriptorBindingStorageBufferUpdateAfterBind;
2221     VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
2222     VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
2223     VkBool32 descriptorBindingUpdateUnusedWhilePending;
2224     VkBool32 descriptorBindingPartiallyBound;
2225     VkBool32 descriptorBindingVariableDescriptorCount;
2226     VkBool32 runtimeDescriptorArray;
2227     VkBool32 samplerFilterMinmax;
2228     VkBool32 scalarBlockLayout;
2229     VkBool32 imagelessFramebuffer;
2230     VkBool32 uniformBufferStandardLayout;
2231     VkBool32 shaderSubgroupExtendedTypes;
2232     VkBool32 separateDepthStencilLayouts;
2233     VkBool32 hostQueryReset;
2234     VkBool32 timelineSemaphore;
2235     VkBool32 bufferDeviceAddress;
2236     VkBool32 bufferDeviceAddressCaptureReplay;
2237     VkBool32 bufferDeviceAddressMultiDevice;
2238     VkBool32 vulkanMemoryModel;
2239     VkBool32 vulkanMemoryModelDeviceScope;
2240     VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
2241     VkBool32 shaderOutputViewportIndex;
2242     VkBool32 shaderOutputLayer;
2243     VkBool32 subgroupBroadcastDynamicId;
2244 } VkPhysicalDeviceVulkan12Features32;
2245
2246 typedef struct VkPhysicalDeviceVulkan13Features32
2247 {
2248     VkStructureType sType;
2249     PTR32 pNext;
2250     VkBool32 robustImageAccess;
2251     VkBool32 inlineUniformBlock;
2252     VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
2253     VkBool32 pipelineCreationCacheControl;
2254     VkBool32 privateData;
2255     VkBool32 shaderDemoteToHelperInvocation;
2256     VkBool32 shaderTerminateInvocation;
2257     VkBool32 subgroupSizeControl;
2258     VkBool32 computeFullSubgroups;
2259     VkBool32 synchronization2;
2260     VkBool32 textureCompressionASTC_HDR;
2261     VkBool32 shaderZeroInitializeWorkgroupMemory;
2262     VkBool32 dynamicRendering;
2263     VkBool32 shaderIntegerDotProduct;
2264     VkBool32 maintenance4;
2265 } VkPhysicalDeviceVulkan13Features32;
2266
2267 typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD32
2268 {
2269     VkStructureType sType;
2270     PTR32 pNext;
2271     VkBool32 deviceCoherentMemory;
2272 } VkPhysicalDeviceCoherentMemoryFeaturesAMD32;
2273
2274 typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT32
2275 {
2276     VkStructureType sType;
2277     PTR32 pNext;
2278     VkBool32 customBorderColors;
2279     VkBool32 customBorderColorWithoutFormat;
2280 } VkPhysicalDeviceCustomBorderColorFeaturesEXT32;
2281
2282 typedef struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32
2283 {
2284     VkStructureType sType;
2285     PTR32 pNext;
2286     VkBool32 borderColorSwizzle;
2287     VkBool32 borderColorSwizzleFromImage;
2288 } VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32;
2289
2290 typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32
2291 {
2292     VkStructureType sType;
2293     PTR32 pNext;
2294     VkBool32 extendedDynamicState;
2295 } VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32;
2296
2297 typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32
2298 {
2299     VkStructureType sType;
2300     PTR32 pNext;
2301     VkBool32 extendedDynamicState2;
2302     VkBool32 extendedDynamicState2LogicOp;
2303     VkBool32 extendedDynamicState2PatchControlPoints;
2304 } VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32;
2305
2306 typedef struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32
2307 {
2308     VkStructureType sType;
2309     PTR32 pNext;
2310     VkBool32 extendedDynamicState3TessellationDomainOrigin;
2311     VkBool32 extendedDynamicState3DepthClampEnable;
2312     VkBool32 extendedDynamicState3PolygonMode;
2313     VkBool32 extendedDynamicState3RasterizationSamples;
2314     VkBool32 extendedDynamicState3SampleMask;
2315     VkBool32 extendedDynamicState3AlphaToCoverageEnable;
2316     VkBool32 extendedDynamicState3AlphaToOneEnable;
2317     VkBool32 extendedDynamicState3LogicOpEnable;
2318     VkBool32 extendedDynamicState3ColorBlendEnable;
2319     VkBool32 extendedDynamicState3ColorBlendEquation;
2320     VkBool32 extendedDynamicState3ColorWriteMask;
2321     VkBool32 extendedDynamicState3RasterizationStream;
2322     VkBool32 extendedDynamicState3ConservativeRasterizationMode;
2323     VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize;
2324     VkBool32 extendedDynamicState3DepthClipEnable;
2325     VkBool32 extendedDynamicState3SampleLocationsEnable;
2326     VkBool32 extendedDynamicState3ColorBlendAdvanced;
2327     VkBool32 extendedDynamicState3ProvokingVertexMode;
2328     VkBool32 extendedDynamicState3LineRasterizationMode;
2329     VkBool32 extendedDynamicState3LineStippleEnable;
2330     VkBool32 extendedDynamicState3DepthClipNegativeOneToOne;
2331     VkBool32 extendedDynamicState3ViewportWScalingEnable;
2332     VkBool32 extendedDynamicState3ViewportSwizzle;
2333     VkBool32 extendedDynamicState3CoverageToColorEnable;
2334     VkBool32 extendedDynamicState3CoverageToColorLocation;
2335     VkBool32 extendedDynamicState3CoverageModulationMode;
2336     VkBool32 extendedDynamicState3CoverageModulationTableEnable;
2337     VkBool32 extendedDynamicState3CoverageModulationTable;
2338     VkBool32 extendedDynamicState3CoverageReductionMode;
2339     VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable;
2340     VkBool32 extendedDynamicState3ShadingRateImageEnable;
2341 } VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32;
2342
2343 typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV32
2344 {
2345     VkStructureType sType;
2346     PTR32 pNext;
2347     VkBool32 diagnosticsConfig;
2348 } VkPhysicalDeviceDiagnosticsConfigFeaturesNV32;
2349
2350 typedef struct VkDeviceDiagnosticsConfigCreateInfoNV32
2351 {
2352     VkStructureType sType;
2353     PTR32 pNext;
2354     VkDeviceDiagnosticsConfigFlagsNV flags;
2355 } VkDeviceDiagnosticsConfigCreateInfoNV32;
2356
2357 typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32
2358 {
2359     VkStructureType sType;
2360     PTR32 pNext;
2361     VkBool32 shaderZeroInitializeWorkgroupMemory;
2362 } VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32;
2363 typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR32;
2364
2365 typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32
2366 {
2367     VkStructureType sType;
2368     PTR32 pNext;
2369     VkBool32 shaderSubgroupUniformControlFlow;
2370 } VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32;
2371
2372 typedef struct VkPhysicalDeviceRobustness2FeaturesEXT32
2373 {
2374     VkStructureType sType;
2375     PTR32 pNext;
2376     VkBool32 robustBufferAccess2;
2377     VkBool32 robustImageAccess2;
2378     VkBool32 nullDescriptor;
2379 } VkPhysicalDeviceRobustness2FeaturesEXT32;
2380
2381 typedef struct VkPhysicalDeviceImageRobustnessFeatures32
2382 {
2383     VkStructureType sType;
2384     PTR32 pNext;
2385     VkBool32 robustImageAccess;
2386 } VkPhysicalDeviceImageRobustnessFeatures32;
2387 typedef VkPhysicalDeviceImageRobustnessFeatures32 VkPhysicalDeviceImageRobustnessFeaturesEXT32;
2388
2389 typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32
2390 {
2391     VkStructureType sType;
2392     PTR32 pNext;
2393     VkBool32 workgroupMemoryExplicitLayout;
2394     VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout;
2395     VkBool32 workgroupMemoryExplicitLayout8BitAccess;
2396     VkBool32 workgroupMemoryExplicitLayout16BitAccess;
2397 } VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32;
2398
2399 typedef struct VkPhysicalDevice4444FormatsFeaturesEXT32
2400 {
2401     VkStructureType sType;
2402     PTR32 pNext;
2403     VkBool32 formatA4R4G4B4;
2404     VkBool32 formatA4B4G4R4;
2405 } VkPhysicalDevice4444FormatsFeaturesEXT32;
2406
2407 typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32
2408 {
2409     VkStructureType sType;
2410     PTR32 pNext;
2411     VkBool32 subpassShading;
2412 } VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32;
2413
2414 typedef struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32
2415 {
2416     VkStructureType sType;
2417     PTR32 pNext;
2418     VkBool32 clustercullingShader;
2419     VkBool32 multiviewClusterCullingShader;
2420 } VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32;
2421
2422 typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32
2423 {
2424     VkStructureType sType;
2425     PTR32 pNext;
2426     VkBool32 shaderImageInt64Atomics;
2427     VkBool32 sparseImageInt64Atomics;
2428 } VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32;
2429
2430 typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR32
2431 {
2432     VkStructureType sType;
2433     PTR32 pNext;
2434     VkBool32 pipelineFragmentShadingRate;
2435     VkBool32 primitiveFragmentShadingRate;
2436     VkBool32 attachmentFragmentShadingRate;
2437 } VkPhysicalDeviceFragmentShadingRateFeaturesKHR32;
2438
2439 typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures32
2440 {
2441     VkStructureType sType;
2442     PTR32 pNext;
2443     VkBool32 shaderTerminateInvocation;
2444 } VkPhysicalDeviceShaderTerminateInvocationFeatures32;
2445 typedef VkPhysicalDeviceShaderTerminateInvocationFeatures32 VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR32;
2446
2447 typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32
2448 {
2449     VkStructureType sType;
2450     PTR32 pNext;
2451     VkBool32 fragmentShadingRateEnums;
2452     VkBool32 supersampleFragmentShadingRates;
2453     VkBool32 noInvocationFragmentShadingRates;
2454 } VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32;
2455
2456 typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32
2457 {
2458     VkStructureType sType;
2459     PTR32 pNext;
2460     VkBool32 image2DViewOf3D;
2461     VkBool32 sampler2DViewOf3D;
2462 } VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32;
2463
2464 typedef struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32
2465 {
2466     VkStructureType sType;
2467     PTR32 pNext;
2468     VkBool32 imageSlicedViewOf3D;
2469 } VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32;
2470
2471 typedef struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32
2472 {
2473     VkStructureType sType;
2474     PTR32 pNext;
2475     VkBool32 attachmentFeedbackLoopDynamicState;
2476 } VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32;
2477
2478 typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32
2479 {
2480     VkStructureType sType;
2481     PTR32 pNext;
2482     VkBool32 mutableDescriptorType;
2483 } VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32;
2484 typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE32;
2485
2486 typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT32
2487 {
2488     VkStructureType sType;
2489     PTR32 pNext;
2490     VkBool32 depthClipControl;
2491 } VkPhysicalDeviceDepthClipControlFeaturesEXT32;
2492
2493 typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32
2494 {
2495     VkStructureType sType;
2496     PTR32 pNext;
2497     VkBool32 vertexInputDynamicState;
2498 } VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32;
2499
2500 typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT32
2501 {
2502     VkStructureType sType;
2503     PTR32 pNext;
2504     VkBool32 colorWriteEnable;
2505 } VkPhysicalDeviceColorWriteEnableFeaturesEXT32;
2506
2507 typedef struct VkPhysicalDeviceSynchronization2Features32
2508 {
2509     VkStructureType sType;
2510     PTR32 pNext;
2511     VkBool32 synchronization2;
2512 } VkPhysicalDeviceSynchronization2Features32;
2513 typedef VkPhysicalDeviceSynchronization2Features32 VkPhysicalDeviceSynchronization2FeaturesKHR32;
2514
2515 typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32
2516 {
2517     VkStructureType sType;
2518     PTR32 pNext;
2519     VkBool32 primitivesGeneratedQuery;
2520     VkBool32 primitivesGeneratedQueryWithRasterizerDiscard;
2521     VkBool32 primitivesGeneratedQueryWithNonZeroStreams;
2522 } VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32;
2523
2524 typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT32
2525 {
2526     VkStructureType sType;
2527     PTR32 pNext;
2528     VkBool32 legacyDithering;
2529 } VkPhysicalDeviceLegacyDitheringFeaturesEXT32;
2530
2531 typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32
2532 {
2533     VkStructureType sType;
2534     PTR32 pNext;
2535     VkBool32 multisampledRenderToSingleSampled;
2536 } VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32;
2537
2538 typedef struct VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32
2539 {
2540     VkStructureType sType;
2541     PTR32 pNext;
2542     VkBool32 pipelineProtectedAccess;
2543 } VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32;
2544
2545 typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV32
2546 {
2547     VkStructureType sType;
2548     PTR32 pNext;
2549     VkBool32 inheritedViewportScissor2D;
2550 } VkPhysicalDeviceInheritedViewportScissorFeaturesNV32;
2551
2552 typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32
2553 {
2554     VkStructureType sType;
2555     PTR32 pNext;
2556     VkBool32 ycbcr2plane444Formats;
2557 } VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32;
2558
2559 typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT32
2560 {
2561     VkStructureType sType;
2562     PTR32 pNext;
2563     VkBool32 provokingVertexLast;
2564     VkBool32 transformFeedbackPreservesProvokingVertex;
2565 } VkPhysicalDeviceProvokingVertexFeaturesEXT32;
2566
2567 typedef struct VkPhysicalDeviceDescriptorBufferFeaturesEXT32
2568 {
2569     VkStructureType sType;
2570     PTR32 pNext;
2571     VkBool32 descriptorBuffer;
2572     VkBool32 descriptorBufferCaptureReplay;
2573     VkBool32 descriptorBufferImageLayoutIgnored;
2574     VkBool32 descriptorBufferPushDescriptors;
2575 } VkPhysicalDeviceDescriptorBufferFeaturesEXT32;
2576
2577 typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures32
2578 {
2579     VkStructureType sType;
2580     PTR32 pNext;
2581     VkBool32 shaderIntegerDotProduct;
2582 } VkPhysicalDeviceShaderIntegerDotProductFeatures32;
2583 typedef VkPhysicalDeviceShaderIntegerDotProductFeatures32 VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR32;
2584
2585 typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32
2586 {
2587     VkStructureType sType;
2588     PTR32 pNext;
2589     VkBool32 fragmentShaderBarycentric;
2590 } VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32;
2591 typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV32;
2592
2593 typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32
2594 {
2595     VkStructureType sType;
2596     PTR32 pNext;
2597     VkBool32 rayTracingMotionBlur;
2598     VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect;
2599 } VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32;
2600
2601 typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32
2602 {
2603     VkStructureType sType;
2604     PTR32 pNext;
2605     VkBool32 formatRgba10x6WithoutYCbCrSampler;
2606 } VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32;
2607
2608 typedef struct VkPhysicalDeviceDynamicRenderingFeatures32
2609 {
2610     VkStructureType sType;
2611     PTR32 pNext;
2612     VkBool32 dynamicRendering;
2613 } VkPhysicalDeviceDynamicRenderingFeatures32;
2614 typedef VkPhysicalDeviceDynamicRenderingFeatures32 VkPhysicalDeviceDynamicRenderingFeaturesKHR32;
2615
2616 typedef struct VkPhysicalDeviceImageViewMinLodFeaturesEXT32
2617 {
2618     VkStructureType sType;
2619     PTR32 pNext;
2620     VkBool32 minLod;
2621 } VkPhysicalDeviceImageViewMinLodFeaturesEXT32;
2622
2623 typedef struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32
2624 {
2625     VkStructureType sType;
2626     PTR32 pNext;
2627     VkBool32 rasterizationOrderColorAttachmentAccess;
2628     VkBool32 rasterizationOrderDepthAttachmentAccess;
2629     VkBool32 rasterizationOrderStencilAttachmentAccess;
2630 } VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32;
2631 typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM32;
2632
2633 typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV32
2634 {
2635     VkStructureType sType;
2636     PTR32 pNext;
2637     VkBool32 linearColorAttachment;
2638 } VkPhysicalDeviceLinearColorAttachmentFeaturesNV32;
2639
2640 typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32
2641 {
2642     VkStructureType sType;
2643     PTR32 pNext;
2644     VkBool32 graphicsPipelineLibrary;
2645 } VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32;
2646
2647 typedef struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32
2648 {
2649     VkStructureType sType;
2650     PTR32 pNext;
2651     VkBool32 descriptorSetHostMapping;
2652 } VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32;
2653
2654 typedef struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32
2655 {
2656     VkStructureType sType;
2657     PTR32 pNext;
2658     VkBool32 shaderModuleIdentifier;
2659 } VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32;
2660
2661 typedef struct VkPhysicalDeviceImageCompressionControlFeaturesEXT32
2662 {
2663     VkStructureType sType;
2664     PTR32 pNext;
2665     VkBool32 imageCompressionControl;
2666 } VkPhysicalDeviceImageCompressionControlFeaturesEXT32;
2667
2668 typedef struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32
2669 {
2670     VkStructureType sType;
2671     PTR32 pNext;
2672     VkBool32 imageCompressionControlSwapchain;
2673 } VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32;
2674
2675 typedef struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32
2676 {
2677     VkStructureType sType;
2678     PTR32 pNext;
2679     VkBool32 subpassMergeFeedback;
2680 } VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32;
2681
2682 typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT32
2683 {
2684     VkStructureType sType;
2685     PTR32 pNext;
2686     VkBool32 micromap;
2687     VkBool32 micromapCaptureReplay;
2688     VkBool32 micromapHostCommands;
2689 } VkPhysicalDeviceOpacityMicromapFeaturesEXT32;
2690
2691 typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT32
2692 {
2693     VkStructureType sType;
2694     PTR32 pNext;
2695     VkBool32 pipelinePropertiesIdentifier;
2696 } VkPhysicalDevicePipelinePropertiesFeaturesEXT32;
2697
2698 typedef struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32
2699 {
2700     VkStructureType sType;
2701     PTR32 pNext;
2702     VkBool32 shaderEarlyAndLateFragmentTests;
2703 } VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32;
2704
2705 typedef struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32
2706 {
2707     VkStructureType sType;
2708     PTR32 pNext;
2709     VkBool32 nonSeamlessCubeMap;
2710 } VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32;
2711
2712 typedef struct VkPhysicalDevicePipelineRobustnessFeaturesEXT32
2713 {
2714     VkStructureType sType;
2715     PTR32 pNext;
2716     VkBool32 pipelineRobustness;
2717 } VkPhysicalDevicePipelineRobustnessFeaturesEXT32;
2718
2719 typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM32
2720 {
2721     VkStructureType sType;
2722     PTR32 pNext;
2723     VkBool32 textureSampleWeighted;
2724     VkBool32 textureBoxFilter;
2725     VkBool32 textureBlockMatch;
2726 } VkPhysicalDeviceImageProcessingFeaturesQCOM32;
2727
2728 typedef struct VkPhysicalDeviceTilePropertiesFeaturesQCOM32
2729 {
2730     VkStructureType sType;
2731     PTR32 pNext;
2732     VkBool32 tileProperties;
2733 } VkPhysicalDeviceTilePropertiesFeaturesQCOM32;
2734
2735 typedef struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32
2736 {
2737     VkStructureType sType;
2738     PTR32 pNext;
2739     VkBool32 attachmentFeedbackLoopLayout;
2740 } VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32;
2741
2742 typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32
2743 {
2744     VkStructureType sType;
2745     PTR32 pNext;
2746     VkBool32 depthClampZeroOne;
2747 } VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32;
2748
2749 typedef struct VkPhysicalDeviceAddressBindingReportFeaturesEXT32
2750 {
2751     VkStructureType sType;
2752     PTR32 pNext;
2753     VkBool32 reportAddressBinding;
2754 } VkPhysicalDeviceAddressBindingReportFeaturesEXT32;
2755
2756 typedef struct VkPhysicalDeviceOpticalFlowFeaturesNV32
2757 {
2758     VkStructureType sType;
2759     PTR32 pNext;
2760     VkBool32 opticalFlow;
2761 } VkPhysicalDeviceOpticalFlowFeaturesNV32;
2762
2763 typedef struct VkPhysicalDeviceFaultFeaturesEXT32
2764 {
2765     VkStructureType sType;
2766     PTR32 pNext;
2767     VkBool32 deviceFault;
2768     VkBool32 deviceFaultVendorBinary;
2769 } VkPhysicalDeviceFaultFeaturesEXT32;
2770
2771 typedef struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32
2772 {
2773     VkStructureType sType;
2774     PTR32 pNext;
2775     VkBool32 pipelineLibraryGroupHandles;
2776 } VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32;
2777
2778 typedef struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32
2779 {
2780     VkStructureType sType;
2781     PTR32 pNext;
2782     VkBool32 shaderCoreBuiltins;
2783 } VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32;
2784
2785 typedef struct VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32
2786 {
2787     VkStructureType sType;
2788     PTR32 pNext;
2789     VkBool32 swapchainMaintenance1;
2790 } VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32;
2791
2792 typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32
2793 {
2794     VkStructureType sType;
2795     PTR32 pNext;
2796     VkBool32 rayTracingInvocationReorder;
2797 } VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32;
2798
2799 typedef struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32
2800 {
2801     VkStructureType sType;
2802     PTR32 pNext;
2803     VkBool32 multiviewPerViewViewports;
2804 } VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32;
2805
2806 typedef struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32
2807 {
2808     VkStructureType sType;
2809     PTR32 pNext;
2810     VkBool32 rayTracingPositionFetch;
2811 } VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32;
2812
2813 typedef struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32
2814 {
2815     VkStructureType sType;
2816     PTR32 pNext;
2817     VkBool32 multiviewPerViewRenderAreas;
2818 } VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32;
2819
2820 typedef struct VkPhysicalDeviceShaderObjectFeaturesEXT32
2821 {
2822     VkStructureType sType;
2823     PTR32 pNext;
2824     VkBool32 shaderObject;
2825 } VkPhysicalDeviceShaderObjectFeaturesEXT32;
2826
2827 typedef struct VkPhysicalDeviceShaderTileImageFeaturesEXT32
2828 {
2829     VkStructureType sType;
2830     PTR32 pNext;
2831     VkBool32 shaderTileImageColorReadAccess;
2832     VkBool32 shaderTileImageDepthReadAccess;
2833     VkBool32 shaderTileImageStencilReadAccess;
2834 } VkPhysicalDeviceShaderTileImageFeaturesEXT32;
2835
2836 typedef struct VkDeviceCreateInfo32
2837 {
2838     VkStructureType sType;
2839     PTR32 pNext;
2840     VkDeviceCreateFlags flags;
2841     uint32_t queueCreateInfoCount;
2842     PTR32 pQueueCreateInfos;
2843     uint32_t enabledLayerCount;
2844     PTR32 ppEnabledLayerNames;
2845     uint32_t enabledExtensionCount;
2846     PTR32 ppEnabledExtensionNames;
2847     PTR32 pEnabledFeatures;
2848 } VkDeviceCreateInfo32;
2849
2850 typedef struct VkEventCreateInfo32
2851 {
2852     VkStructureType sType;
2853     PTR32 pNext;
2854     VkEventCreateFlags flags;
2855 } VkEventCreateInfo32;
2856
2857 typedef struct VkExportFenceCreateInfo32
2858 {
2859     VkStructureType sType;
2860     PTR32 pNext;
2861     VkExternalFenceHandleTypeFlags handleTypes;
2862 } VkExportFenceCreateInfo32;
2863 typedef VkExportFenceCreateInfo32 VkExportFenceCreateInfoKHR32;
2864
2865 typedef struct VkFenceCreateInfo32
2866 {
2867     VkStructureType sType;
2868     PTR32 pNext;
2869     VkFenceCreateFlags flags;
2870 } VkFenceCreateInfo32;
2871
2872 typedef struct VkFramebufferAttachmentImageInfo32
2873 {
2874     VkStructureType sType;
2875     PTR32 pNext;
2876     VkImageCreateFlags flags;
2877     VkImageUsageFlags usage;
2878     uint32_t width;
2879     uint32_t height;
2880     uint32_t layerCount;
2881     uint32_t viewFormatCount;
2882     PTR32 pViewFormats;
2883 } VkFramebufferAttachmentImageInfo32;
2884 typedef VkFramebufferAttachmentImageInfo32 VkFramebufferAttachmentImageInfoKHR32;
2885
2886 typedef struct VkFramebufferAttachmentsCreateInfo32
2887 {
2888     VkStructureType sType;
2889     PTR32 pNext;
2890     uint32_t attachmentImageInfoCount;
2891     PTR32 pAttachmentImageInfos;
2892 } VkFramebufferAttachmentsCreateInfo32;
2893 typedef VkFramebufferAttachmentsCreateInfo32 VkFramebufferAttachmentsCreateInfoKHR32;
2894
2895 typedef struct VkFramebufferCreateInfo32
2896 {
2897     VkStructureType sType;
2898     PTR32 pNext;
2899     VkFramebufferCreateFlags flags;
2900     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
2901     uint32_t attachmentCount;
2902     PTR32 pAttachments;
2903     uint32_t width;
2904     uint32_t height;
2905     uint32_t layers;
2906 } VkFramebufferCreateInfo32;
2907
2908 typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT32
2909 {
2910     VkStructureType sType;
2911     PTR32 pNext;
2912     uint32_t vertexBindingDivisorCount;
2913     PTR32 pVertexBindingDivisors;
2914 } VkPipelineVertexInputDivisorStateCreateInfoEXT32;
2915
2916 typedef struct VkPipelineVertexInputStateCreateInfo32
2917 {
2918     VkStructureType sType;
2919     PTR32 pNext;
2920     VkPipelineVertexInputStateCreateFlags flags;
2921     uint32_t vertexBindingDescriptionCount;
2922     PTR32 pVertexBindingDescriptions;
2923     uint32_t vertexAttributeDescriptionCount;
2924     PTR32 pVertexAttributeDescriptions;
2925 } VkPipelineVertexInputStateCreateInfo32;
2926
2927 typedef struct VkPipelineTessellationDomainOriginStateCreateInfo32
2928 {
2929     VkStructureType sType;
2930     PTR32 pNext;
2931     VkTessellationDomainOrigin domainOrigin;
2932 } VkPipelineTessellationDomainOriginStateCreateInfo32;
2933 typedef VkPipelineTessellationDomainOriginStateCreateInfo32 VkPipelineTessellationDomainOriginStateCreateInfoKHR32;
2934
2935 typedef struct VkPipelineTessellationStateCreateInfo32
2936 {
2937     VkStructureType sType;
2938     PTR32 pNext;
2939     VkPipelineTessellationStateCreateFlags flags;
2940     uint32_t patchControlPoints;
2941 } VkPipelineTessellationStateCreateInfo32;
2942
2943 typedef struct VkGraphicsShaderGroupCreateInfoNV32
2944 {
2945     VkStructureType sType;
2946     PTR32 pNext;
2947     uint32_t stageCount;
2948     PTR32 pStages;
2949     PTR32 pVertexInputState;
2950     PTR32 pTessellationState;
2951 } VkGraphicsShaderGroupCreateInfoNV32;
2952
2953 typedef struct VkPipelineInputAssemblyStateCreateInfo32
2954 {
2955     VkStructureType sType;
2956     PTR32 pNext;
2957     VkPipelineInputAssemblyStateCreateFlags flags;
2958     VkPrimitiveTopology topology;
2959     VkBool32 primitiveRestartEnable;
2960 } VkPipelineInputAssemblyStateCreateInfo32;
2961
2962 typedef struct VkPipelineViewportWScalingStateCreateInfoNV32
2963 {
2964     VkStructureType sType;
2965     PTR32 pNext;
2966     VkBool32 viewportWScalingEnable;
2967     uint32_t viewportCount;
2968     PTR32 pViewportWScalings;
2969 } VkPipelineViewportWScalingStateCreateInfoNV32;
2970
2971 typedef struct VkPipelineViewportSwizzleStateCreateInfoNV32
2972 {
2973     VkStructureType sType;
2974     PTR32 pNext;
2975     VkPipelineViewportSwizzleStateCreateFlagsNV flags;
2976     uint32_t viewportCount;
2977     PTR32 pViewportSwizzles;
2978 } VkPipelineViewportSwizzleStateCreateInfoNV32;
2979
2980 typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV32
2981 {
2982     VkStructureType sType;
2983     PTR32 pNext;
2984     uint32_t exclusiveScissorCount;
2985     PTR32 pExclusiveScissors;
2986 } VkPipelineViewportExclusiveScissorStateCreateInfoNV32;
2987
2988 typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV32
2989 {
2990     VkStructureType sType;
2991     PTR32 pNext;
2992     VkBool32 shadingRateImageEnable;
2993     uint32_t viewportCount;
2994     PTR32 pShadingRatePalettes;
2995 } VkPipelineViewportShadingRateImageStateCreateInfoNV32;
2996
2997 typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32
2998 {
2999     VkStructureType sType;
3000     PTR32 pNext;
3001     VkCoarseSampleOrderTypeNV sampleOrderType;
3002     uint32_t customSampleOrderCount;
3003     PTR32 pCustomSampleOrders;
3004 } VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32;
3005
3006 typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT32
3007 {
3008     VkStructureType sType;
3009     PTR32 pNext;
3010     VkBool32 negativeOneToOne;
3011 } VkPipelineViewportDepthClipControlCreateInfoEXT32;
3012
3013 typedef struct VkPipelineViewportStateCreateInfo32
3014 {
3015     VkStructureType sType;
3016     PTR32 pNext;
3017     VkPipelineViewportStateCreateFlags flags;
3018     uint32_t viewportCount;
3019     PTR32 pViewports;
3020     uint32_t scissorCount;
3021     PTR32 pScissors;
3022 } VkPipelineViewportStateCreateInfo32;
3023
3024 typedef struct VkPipelineRasterizationStateRasterizationOrderAMD32
3025 {
3026     VkStructureType sType;
3027     PTR32 pNext;
3028     VkRasterizationOrderAMD rasterizationOrder;
3029 } VkPipelineRasterizationStateRasterizationOrderAMD32;
3030
3031 typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT32
3032 {
3033     VkStructureType sType;
3034     PTR32 pNext;
3035     VkPipelineRasterizationConservativeStateCreateFlagsEXT flags;
3036     VkConservativeRasterizationModeEXT conservativeRasterizationMode;
3037     float extraPrimitiveOverestimationSize;
3038 } VkPipelineRasterizationConservativeStateCreateInfoEXT32;
3039
3040 typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT32
3041 {
3042     VkStructureType sType;
3043     PTR32 pNext;
3044     VkPipelineRasterizationStateStreamCreateFlagsEXT flags;
3045     uint32_t rasterizationStream;
3046 } VkPipelineRasterizationStateStreamCreateInfoEXT32;
3047
3048 typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT32
3049 {
3050     VkStructureType sType;
3051     PTR32 pNext;
3052     VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags;
3053     VkBool32 depthClipEnable;
3054 } VkPipelineRasterizationDepthClipStateCreateInfoEXT32;
3055
3056 typedef struct VkPipelineRasterizationLineStateCreateInfoEXT32
3057 {
3058     VkStructureType sType;
3059     PTR32 pNext;
3060     VkLineRasterizationModeEXT lineRasterizationMode;
3061     VkBool32 stippledLineEnable;
3062     uint32_t lineStippleFactor;
3063     uint16_t lineStipplePattern;
3064 } VkPipelineRasterizationLineStateCreateInfoEXT32;
3065
3066 typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32
3067 {
3068     VkStructureType sType;
3069     PTR32 pNext;
3070     VkProvokingVertexModeEXT provokingVertexMode;
3071 } VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32;
3072
3073 typedef struct VkPipelineRasterizationStateCreateInfo32
3074 {
3075     VkStructureType sType;
3076     PTR32 pNext;
3077     VkPipelineRasterizationStateCreateFlags flags;
3078     VkBool32 depthClampEnable;
3079     VkBool32 rasterizerDiscardEnable;
3080     VkPolygonMode polygonMode;
3081     VkCullModeFlags cullMode;
3082     VkFrontFace frontFace;
3083     VkBool32 depthBiasEnable;
3084     float depthBiasConstantFactor;
3085     float depthBiasClamp;
3086     float depthBiasSlopeFactor;
3087     float lineWidth;
3088 } VkPipelineRasterizationStateCreateInfo32;
3089
3090 typedef struct VkPipelineCoverageToColorStateCreateInfoNV32
3091 {
3092     VkStructureType sType;
3093     PTR32 pNext;
3094     VkPipelineCoverageToColorStateCreateFlagsNV flags;
3095     VkBool32 coverageToColorEnable;
3096     uint32_t coverageToColorLocation;
3097 } VkPipelineCoverageToColorStateCreateInfoNV32;
3098
3099 typedef struct VkPipelineSampleLocationsStateCreateInfoEXT32
3100 {
3101     VkStructureType sType;
3102     PTR32 pNext;
3103     VkBool32 sampleLocationsEnable;
3104     VkSampleLocationsInfoEXT32 sampleLocationsInfo;
3105 } VkPipelineSampleLocationsStateCreateInfoEXT32;
3106
3107 typedef struct VkPipelineCoverageModulationStateCreateInfoNV32
3108 {
3109     VkStructureType sType;
3110     PTR32 pNext;
3111     VkPipelineCoverageModulationStateCreateFlagsNV flags;
3112     VkCoverageModulationModeNV coverageModulationMode;
3113     VkBool32 coverageModulationTableEnable;
3114     uint32_t coverageModulationTableCount;
3115     PTR32 pCoverageModulationTable;
3116 } VkPipelineCoverageModulationStateCreateInfoNV32;
3117
3118 typedef struct VkPipelineCoverageReductionStateCreateInfoNV32
3119 {
3120     VkStructureType sType;
3121     PTR32 pNext;
3122     VkPipelineCoverageReductionStateCreateFlagsNV flags;
3123     VkCoverageReductionModeNV coverageReductionMode;
3124 } VkPipelineCoverageReductionStateCreateInfoNV32;
3125
3126 typedef struct VkPipelineMultisampleStateCreateInfo32
3127 {
3128     VkStructureType sType;
3129     PTR32 pNext;
3130     VkPipelineMultisampleStateCreateFlags flags;
3131     VkSampleCountFlagBits rasterizationSamples;
3132     VkBool32 sampleShadingEnable;
3133     float minSampleShading;
3134     PTR32 pSampleMask;
3135     VkBool32 alphaToCoverageEnable;
3136     VkBool32 alphaToOneEnable;
3137 } VkPipelineMultisampleStateCreateInfo32;
3138
3139 typedef struct VkPipelineDepthStencilStateCreateInfo32
3140 {
3141     VkStructureType sType;
3142     PTR32 pNext;
3143     VkPipelineDepthStencilStateCreateFlags flags;
3144     VkBool32 depthTestEnable;
3145     VkBool32 depthWriteEnable;
3146     VkCompareOp depthCompareOp;
3147     VkBool32 depthBoundsTestEnable;
3148     VkBool32 stencilTestEnable;
3149     VkStencilOpState front;
3150     VkStencilOpState back;
3151     float minDepthBounds;
3152     float maxDepthBounds;
3153 } VkPipelineDepthStencilStateCreateInfo32;
3154
3155 typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT32
3156 {
3157     VkStructureType sType;
3158     PTR32 pNext;
3159     VkBool32 srcPremultiplied;
3160     VkBool32 dstPremultiplied;
3161     VkBlendOverlapEXT blendOverlap;
3162 } VkPipelineColorBlendAdvancedStateCreateInfoEXT32;
3163
3164 typedef struct VkPipelineColorWriteCreateInfoEXT32
3165 {
3166     VkStructureType sType;
3167     PTR32 pNext;
3168     uint32_t attachmentCount;
3169     PTR32 pColorWriteEnables;
3170 } VkPipelineColorWriteCreateInfoEXT32;
3171
3172 typedef struct VkPipelineColorBlendStateCreateInfo32
3173 {
3174     VkStructureType sType;
3175     PTR32 pNext;
3176     VkPipelineColorBlendStateCreateFlags flags;
3177     VkBool32 logicOpEnable;
3178     VkLogicOp logicOp;
3179     uint32_t attachmentCount;
3180     PTR32 pAttachments;
3181     float blendConstants[4];
3182 } VkPipelineColorBlendStateCreateInfo32;
3183
3184 typedef struct VkPipelineDynamicStateCreateInfo32
3185 {
3186     VkStructureType sType;
3187     PTR32 pNext;
3188     VkPipelineDynamicStateCreateFlags flags;
3189     uint32_t dynamicStateCount;
3190     PTR32 pDynamicStates;
3191 } VkPipelineDynamicStateCreateInfo32;
3192
3193 typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV32
3194 {
3195     VkStructureType sType;
3196     PTR32 pNext;
3197     uint32_t groupCount;
3198     PTR32 pGroups;
3199     uint32_t pipelineCount;
3200     PTR32 pPipelines;
3201 } VkGraphicsPipelineShaderGroupsCreateInfoNV32;
3202
3203 typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT32
3204 {
3205     VkStructureType sType;
3206     PTR32 pNext;
3207     VkPipelineDiscardRectangleStateCreateFlagsEXT flags;
3208     VkDiscardRectangleModeEXT discardRectangleMode;
3209     uint32_t discardRectangleCount;
3210     PTR32 pDiscardRectangles;
3211 } VkPipelineDiscardRectangleStateCreateInfoEXT32;
3212
3213 typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV32
3214 {
3215     VkStructureType sType;
3216     PTR32 pNext;
3217     VkBool32 representativeFragmentTestEnable;
3218 } VkPipelineRepresentativeFragmentTestStateCreateInfoNV32;
3219
3220 typedef struct VkPipelineLibraryCreateInfoKHR32
3221 {
3222     VkStructureType sType;
3223     PTR32 pNext;
3224     uint32_t libraryCount;
3225     PTR32 pLibraries;
3226 } VkPipelineLibraryCreateInfoKHR32;
3227
3228 typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR32
3229 {
3230     VkStructureType sType;
3231     PTR32 pNext;
3232     VkExtent2D fragmentSize;
3233     VkFragmentShadingRateCombinerOpKHR combinerOps[2];
3234 } VkPipelineFragmentShadingRateStateCreateInfoKHR32;
3235
3236 typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV32
3237 {
3238     VkStructureType sType;
3239     PTR32 pNext;
3240     VkFragmentShadingRateTypeNV shadingRateType;
3241     VkFragmentShadingRateNV shadingRate;
3242     VkFragmentShadingRateCombinerOpKHR combinerOps[2];
3243 } VkPipelineFragmentShadingRateEnumStateCreateInfoNV32;
3244
3245 typedef struct VkPipelineRenderingCreateInfo32
3246 {
3247     VkStructureType sType;
3248     PTR32 pNext;
3249     uint32_t viewMask;
3250     uint32_t colorAttachmentCount;
3251     PTR32 pColorAttachmentFormats;
3252     VkFormat depthAttachmentFormat;
3253     VkFormat stencilAttachmentFormat;
3254 } VkPipelineRenderingCreateInfo32;
3255 typedef VkPipelineRenderingCreateInfo32 VkPipelineRenderingCreateInfoKHR32;
3256
3257 typedef struct VkGraphicsPipelineLibraryCreateInfoEXT32
3258 {
3259     VkStructureType sType;
3260     PTR32 pNext;
3261     VkGraphicsPipelineLibraryFlagsEXT flags;
3262 } VkGraphicsPipelineLibraryCreateInfoEXT32;
3263
3264 typedef struct VkGraphicsPipelineCreateInfo32
3265 {
3266     VkStructureType sType;
3267     PTR32 pNext;
3268     VkPipelineCreateFlags flags;
3269     uint32_t stageCount;
3270     PTR32 pStages;
3271     PTR32 pVertexInputState;
3272     PTR32 pInputAssemblyState;
3273     PTR32 pTessellationState;
3274     PTR32 pViewportState;
3275     PTR32 pRasterizationState;
3276     PTR32 pMultisampleState;
3277     PTR32 pDepthStencilState;
3278     PTR32 pColorBlendState;
3279     PTR32 pDynamicState;
3280     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
3281     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
3282     uint32_t subpass;
3283     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
3284     int32_t basePipelineIndex;
3285 } VkGraphicsPipelineCreateInfo32;
3286
3287 typedef struct VkDedicatedAllocationImageCreateInfoNV32
3288 {
3289     VkStructureType sType;
3290     PTR32 pNext;
3291     VkBool32 dedicatedAllocation;
3292 } VkDedicatedAllocationImageCreateInfoNV32;
3293
3294 typedef struct VkExternalMemoryImageCreateInfo32
3295 {
3296     VkStructureType sType;
3297     PTR32 pNext;
3298     VkExternalMemoryHandleTypeFlags handleTypes;
3299 } VkExternalMemoryImageCreateInfo32;
3300 typedef VkExternalMemoryImageCreateInfo32 VkExternalMemoryImageCreateInfoKHR32;
3301
3302 typedef struct VkImageSwapchainCreateInfoKHR32
3303 {
3304     VkStructureType sType;
3305     PTR32 pNext;
3306     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
3307 } VkImageSwapchainCreateInfoKHR32;
3308
3309 typedef struct VkImageFormatListCreateInfo32
3310 {
3311     VkStructureType sType;
3312     PTR32 pNext;
3313     uint32_t viewFormatCount;
3314     PTR32 pViewFormats;
3315 } VkImageFormatListCreateInfo32;
3316 typedef VkImageFormatListCreateInfo32 VkImageFormatListCreateInfoKHR32;
3317
3318 typedef struct VkImageStencilUsageCreateInfo32
3319 {
3320     VkStructureType sType;
3321     PTR32 pNext;
3322     VkImageUsageFlags stencilUsage;
3323 } VkImageStencilUsageCreateInfo32;
3324 typedef VkImageStencilUsageCreateInfo32 VkImageStencilUsageCreateInfoEXT32;
3325
3326 typedef struct VkImageCompressionControlEXT32
3327 {
3328     VkStructureType sType;
3329     PTR32 pNext;
3330     VkImageCompressionFlagsEXT flags;
3331     uint32_t compressionControlPlaneCount;
3332     PTR32 pFixedRateFlags;
3333 } VkImageCompressionControlEXT32;
3334
3335 typedef struct VkOpticalFlowImageFormatInfoNV32
3336 {
3337     VkStructureType sType;
3338     PTR32 pNext;
3339     VkOpticalFlowUsageFlagsNV usage;
3340 } VkOpticalFlowImageFormatInfoNV32;
3341
3342 typedef struct VkImageCreateInfo32
3343 {
3344     VkStructureType sType;
3345     PTR32 pNext;
3346     VkImageCreateFlags flags;
3347     VkImageType imageType;
3348     VkFormat format;
3349     VkExtent3D extent;
3350     uint32_t mipLevels;
3351     uint32_t arrayLayers;
3352     VkSampleCountFlagBits samples;
3353     VkImageTiling tiling;
3354     VkImageUsageFlags usage;
3355     VkSharingMode sharingMode;
3356     uint32_t queueFamilyIndexCount;
3357     PTR32 pQueueFamilyIndices;
3358     VkImageLayout initialLayout;
3359 } VkImageCreateInfo32;
3360
3361 typedef struct VkImageViewUsageCreateInfo32
3362 {
3363     VkStructureType sType;
3364     PTR32 pNext;
3365     VkImageUsageFlags usage;
3366 } VkImageViewUsageCreateInfo32;
3367 typedef VkImageViewUsageCreateInfo32 VkImageViewUsageCreateInfoKHR32;
3368
3369 typedef struct VkImageViewSlicedCreateInfoEXT32
3370 {
3371     VkStructureType sType;
3372     PTR32 pNext;
3373     uint32_t sliceOffset;
3374     uint32_t sliceCount;
3375 } VkImageViewSlicedCreateInfoEXT32;
3376
3377 typedef struct VkSamplerYcbcrConversionInfo32
3378 {
3379     VkStructureType sType;
3380     PTR32 pNext;
3381     VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) conversion;
3382 } VkSamplerYcbcrConversionInfo32;
3383 typedef VkSamplerYcbcrConversionInfo32 VkSamplerYcbcrConversionInfoKHR32;
3384
3385 typedef struct VkImageViewASTCDecodeModeEXT32
3386 {
3387     VkStructureType sType;
3388     PTR32 pNext;
3389     VkFormat decodeMode;
3390 } VkImageViewASTCDecodeModeEXT32;
3391
3392 typedef struct VkImageViewMinLodCreateInfoEXT32
3393 {
3394     VkStructureType sType;
3395     PTR32 pNext;
3396     float minLod;
3397 } VkImageViewMinLodCreateInfoEXT32;
3398
3399 typedef struct VkImageViewSampleWeightCreateInfoQCOM32
3400 {
3401     VkStructureType sType;
3402     PTR32 pNext;
3403     VkOffset2D filterCenter;
3404     VkExtent2D filterSize;
3405     uint32_t numPhases;
3406 } VkImageViewSampleWeightCreateInfoQCOM32;
3407
3408 typedef struct VkImageViewCreateInfo32
3409 {
3410     VkStructureType sType;
3411     PTR32 pNext;
3412     VkImageViewCreateFlags flags;
3413     VkImage DECLSPEC_ALIGN(8) image;
3414     VkImageViewType viewType;
3415     VkFormat format;
3416     VkComponentMapping components;
3417     VkImageSubresourceRange subresourceRange;
3418 } VkImageViewCreateInfo32;
3419
3420 typedef struct VkIndirectCommandsLayoutTokenNV32
3421 {
3422     VkStructureType sType;
3423     PTR32 pNext;
3424     VkIndirectCommandsTokenTypeNV tokenType;
3425     uint32_t stream;
3426     uint32_t offset;
3427     uint32_t vertexBindingUnit;
3428     VkBool32 vertexDynamicStride;
3429     VkPipelineLayout DECLSPEC_ALIGN(8) pushconstantPipelineLayout;
3430     VkShaderStageFlags pushconstantShaderStageFlags;
3431     uint32_t pushconstantOffset;
3432     uint32_t pushconstantSize;
3433     VkIndirectStateFlagsNV indirectStateFlags;
3434     uint32_t indexTypeCount;
3435     PTR32 pIndexTypes;
3436     PTR32 pIndexTypeValues;
3437 } VkIndirectCommandsLayoutTokenNV32;
3438
3439 typedef struct VkIndirectCommandsLayoutCreateInfoNV32
3440 {
3441     VkStructureType sType;
3442     PTR32 pNext;
3443     VkIndirectCommandsLayoutUsageFlagsNV flags;
3444     VkPipelineBindPoint pipelineBindPoint;
3445     uint32_t tokenCount;
3446     PTR32 pTokens;
3447     uint32_t streamCount;
3448     PTR32 pStreamStrides;
3449 } VkIndirectCommandsLayoutCreateInfoNV32;
3450
3451 typedef struct VkApplicationInfo32
3452 {
3453     VkStructureType sType;
3454     PTR32 pNext;
3455     PTR32 pApplicationName;
3456     uint32_t applicationVersion;
3457     PTR32 pEngineName;
3458     uint32_t engineVersion;
3459     uint32_t apiVersion;
3460 } VkApplicationInfo32;
3461
3462 typedef struct VkValidationFlagsEXT32
3463 {
3464     VkStructureType sType;
3465     PTR32 pNext;
3466     uint32_t disabledValidationCheckCount;
3467     PTR32 pDisabledValidationChecks;
3468 } VkValidationFlagsEXT32;
3469
3470 typedef struct VkValidationFeaturesEXT32
3471 {
3472     VkStructureType sType;
3473     PTR32 pNext;
3474     uint32_t enabledValidationFeatureCount;
3475     PTR32 pEnabledValidationFeatures;
3476     uint32_t disabledValidationFeatureCount;
3477     PTR32 pDisabledValidationFeatures;
3478 } VkValidationFeaturesEXT32;
3479
3480 typedef struct VkInstanceCreateInfo32
3481 {
3482     VkStructureType sType;
3483     PTR32 pNext;
3484     VkInstanceCreateFlags flags;
3485     PTR32 pApplicationInfo;
3486     uint32_t enabledLayerCount;
3487     PTR32 ppEnabledLayerNames;
3488     uint32_t enabledExtensionCount;
3489     PTR32 ppEnabledExtensionNames;
3490 } VkInstanceCreateInfo32;
3491
3492 typedef struct VkMicromapCreateInfoEXT32
3493 {
3494     VkStructureType sType;
3495     PTR32 pNext;
3496     VkMicromapCreateFlagsEXT createFlags;
3497     VkBuffer DECLSPEC_ALIGN(8) buffer;
3498     VkDeviceSize DECLSPEC_ALIGN(8) offset;
3499     VkDeviceSize DECLSPEC_ALIGN(8) size;
3500     VkMicromapTypeEXT type;
3501     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
3502 } VkMicromapCreateInfoEXT32;
3503
3504 typedef struct VkOpticalFlowSessionCreatePrivateDataInfoNV32
3505 {
3506     VkStructureType sType;
3507     PTR32 pNext;
3508     uint32_t id;
3509     uint32_t size;
3510     PTR32 pPrivateData;
3511 } VkOpticalFlowSessionCreatePrivateDataInfoNV32;
3512
3513 typedef struct VkOpticalFlowSessionCreateInfoNV32
3514 {
3515     VkStructureType sType;
3516     PTR32 pNext;
3517     uint32_t width;
3518     uint32_t height;
3519     VkFormat imageFormat;
3520     VkFormat flowVectorFormat;
3521     VkFormat costFormat;
3522     VkOpticalFlowGridSizeFlagsNV outputGridSize;
3523     VkOpticalFlowGridSizeFlagsNV hintGridSize;
3524     VkOpticalFlowPerformanceLevelNV performanceLevel;
3525     VkOpticalFlowSessionCreateFlagsNV flags;
3526 } VkOpticalFlowSessionCreateInfoNV32;
3527
3528 typedef struct VkPipelineCacheCreateInfo32
3529 {
3530     VkStructureType sType;
3531     PTR32 pNext;
3532     VkPipelineCacheCreateFlags flags;
3533     PTR32 initialDataSize;
3534     PTR32 pInitialData;
3535 } VkPipelineCacheCreateInfo32;
3536
3537 typedef struct VkPipelineLayoutCreateInfo32
3538 {
3539     VkStructureType sType;
3540     PTR32 pNext;
3541     VkPipelineLayoutCreateFlags flags;
3542     uint32_t setLayoutCount;
3543     PTR32 pSetLayouts;
3544     uint32_t pushConstantRangeCount;
3545     PTR32 pPushConstantRanges;
3546 } VkPipelineLayoutCreateInfo32;
3547
3548 typedef struct VkPrivateDataSlotCreateInfo32
3549 {
3550     VkStructureType sType;
3551     PTR32 pNext;
3552     VkPrivateDataSlotCreateFlags flags;
3553 } VkPrivateDataSlotCreateInfo32;
3554 typedef VkPrivateDataSlotCreateInfo32 VkPrivateDataSlotCreateInfoEXT32;
3555
3556 typedef struct VkQueryPoolPerformanceCreateInfoKHR32
3557 {
3558     VkStructureType sType;
3559     PTR32 pNext;
3560     uint32_t queueFamilyIndex;
3561     uint32_t counterIndexCount;
3562     PTR32 pCounterIndices;
3563 } VkQueryPoolPerformanceCreateInfoKHR32;
3564
3565 typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL32
3566 {
3567     VkStructureType sType;
3568     PTR32 pNext;
3569     VkQueryPoolSamplingModeINTEL performanceCountersSampling;
3570 } VkQueryPoolPerformanceQueryCreateInfoINTEL32;
3571 typedef VkQueryPoolPerformanceQueryCreateInfoINTEL32 VkQueryPoolCreateInfoINTEL32;
3572
3573 typedef struct VkQueryPoolCreateInfo32
3574 {
3575     VkStructureType sType;
3576     PTR32 pNext;
3577     VkQueryPoolCreateFlags flags;
3578     VkQueryType queryType;
3579     uint32_t queryCount;
3580     VkQueryPipelineStatisticFlags pipelineStatistics;
3581 } VkQueryPoolCreateInfo32;
3582
3583 typedef struct VkRayTracingShaderGroupCreateInfoKHR32
3584 {
3585     VkStructureType sType;
3586     PTR32 pNext;
3587     VkRayTracingShaderGroupTypeKHR type;
3588     uint32_t generalShader;
3589     uint32_t closestHitShader;
3590     uint32_t anyHitShader;
3591     uint32_t intersectionShader;
3592     PTR32 pShaderGroupCaptureReplayHandle;
3593 } VkRayTracingShaderGroupCreateInfoKHR32;
3594
3595 typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR32
3596 {
3597     VkStructureType sType;
3598     PTR32 pNext;
3599     uint32_t maxPipelineRayPayloadSize;
3600     uint32_t maxPipelineRayHitAttributeSize;
3601 } VkRayTracingPipelineInterfaceCreateInfoKHR32;
3602
3603 typedef struct VkRayTracingPipelineCreateInfoKHR32
3604 {
3605     VkStructureType sType;
3606     PTR32 pNext;
3607     VkPipelineCreateFlags flags;
3608     uint32_t stageCount;
3609     PTR32 pStages;
3610     uint32_t groupCount;
3611     PTR32 pGroups;
3612     uint32_t maxPipelineRayRecursionDepth;
3613     PTR32 pLibraryInfo;
3614     PTR32 pLibraryInterface;
3615     PTR32 pDynamicState;
3616     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
3617     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
3618     int32_t basePipelineIndex;
3619 } VkRayTracingPipelineCreateInfoKHR32;
3620
3621 typedef struct VkRayTracingShaderGroupCreateInfoNV32
3622 {
3623     VkStructureType sType;
3624     PTR32 pNext;
3625     VkRayTracingShaderGroupTypeKHR type;
3626     uint32_t generalShader;
3627     uint32_t closestHitShader;
3628     uint32_t anyHitShader;
3629     uint32_t intersectionShader;
3630 } VkRayTracingShaderGroupCreateInfoNV32;
3631
3632 typedef struct VkRayTracingPipelineCreateInfoNV32
3633 {
3634     VkStructureType sType;
3635     PTR32 pNext;
3636     VkPipelineCreateFlags flags;
3637     uint32_t stageCount;
3638     PTR32 pStages;
3639     uint32_t groupCount;
3640     PTR32 pGroups;
3641     uint32_t maxRecursionDepth;
3642     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
3643     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
3644     int32_t basePipelineIndex;
3645 } VkRayTracingPipelineCreateInfoNV32;
3646
3647 typedef struct VkSubpassDescription32
3648 {
3649     VkSubpassDescriptionFlags flags;
3650     VkPipelineBindPoint pipelineBindPoint;
3651     uint32_t inputAttachmentCount;
3652     PTR32 pInputAttachments;
3653     uint32_t colorAttachmentCount;
3654     PTR32 pColorAttachments;
3655     PTR32 pResolveAttachments;
3656     PTR32 pDepthStencilAttachment;
3657     uint32_t preserveAttachmentCount;
3658     PTR32 pPreserveAttachments;
3659 } VkSubpassDescription32;
3660
3661 typedef struct VkRenderPassMultiviewCreateInfo32
3662 {
3663     VkStructureType sType;
3664     PTR32 pNext;
3665     uint32_t subpassCount;
3666     PTR32 pViewMasks;
3667     uint32_t dependencyCount;
3668     PTR32 pViewOffsets;
3669     uint32_t correlationMaskCount;
3670     PTR32 pCorrelationMasks;
3671 } VkRenderPassMultiviewCreateInfo32;
3672 typedef VkRenderPassMultiviewCreateInfo32 VkRenderPassMultiviewCreateInfoKHR32;
3673
3674 typedef struct VkRenderPassInputAttachmentAspectCreateInfo32
3675 {
3676     VkStructureType sType;
3677     PTR32 pNext;
3678     uint32_t aspectReferenceCount;
3679     PTR32 pAspectReferences;
3680 } VkRenderPassInputAttachmentAspectCreateInfo32;
3681 typedef VkRenderPassInputAttachmentAspectCreateInfo32 VkRenderPassInputAttachmentAspectCreateInfoKHR32;
3682
3683 typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT32
3684 {
3685     VkStructureType sType;
3686     PTR32 pNext;
3687     VkAttachmentReference fragmentDensityMapAttachment;
3688 } VkRenderPassFragmentDensityMapCreateInfoEXT32;
3689
3690 typedef struct VkRenderPassCreateInfo32
3691 {
3692     VkStructureType sType;
3693     PTR32 pNext;
3694     VkRenderPassCreateFlags flags;
3695     uint32_t attachmentCount;
3696     PTR32 pAttachments;
3697     uint32_t subpassCount;
3698     PTR32 pSubpasses;
3699     uint32_t dependencyCount;
3700     PTR32 pDependencies;
3701 } VkRenderPassCreateInfo32;
3702
3703 typedef struct VkAttachmentDescriptionStencilLayout32
3704 {
3705     VkStructureType sType;
3706     PTR32 pNext;
3707     VkImageLayout stencilInitialLayout;
3708     VkImageLayout stencilFinalLayout;
3709 } VkAttachmentDescriptionStencilLayout32;
3710 typedef VkAttachmentDescriptionStencilLayout32 VkAttachmentDescriptionStencilLayoutKHR32;
3711
3712 typedef struct VkAttachmentDescription232
3713 {
3714     VkStructureType sType;
3715     PTR32 pNext;
3716     VkAttachmentDescriptionFlags flags;
3717     VkFormat format;
3718     VkSampleCountFlagBits samples;
3719     VkAttachmentLoadOp loadOp;
3720     VkAttachmentStoreOp storeOp;
3721     VkAttachmentLoadOp stencilLoadOp;
3722     VkAttachmentStoreOp stencilStoreOp;
3723     VkImageLayout initialLayout;
3724     VkImageLayout finalLayout;
3725 } VkAttachmentDescription232;
3726 typedef VkAttachmentDescription232 VkAttachmentDescription2KHR32;
3727
3728 typedef struct VkAttachmentReferenceStencilLayout32
3729 {
3730     VkStructureType sType;
3731     PTR32 pNext;
3732     VkImageLayout stencilLayout;
3733 } VkAttachmentReferenceStencilLayout32;
3734 typedef VkAttachmentReferenceStencilLayout32 VkAttachmentReferenceStencilLayoutKHR32;
3735
3736 typedef struct VkAttachmentReference232
3737 {
3738     VkStructureType sType;
3739     PTR32 pNext;
3740     uint32_t attachment;
3741     VkImageLayout layout;
3742     VkImageAspectFlags aspectMask;
3743 } VkAttachmentReference232;
3744 typedef VkAttachmentReference232 VkAttachmentReference2KHR32;
3745
3746 typedef struct VkSubpassDescriptionDepthStencilResolve32
3747 {
3748     VkStructureType sType;
3749     PTR32 pNext;
3750     VkResolveModeFlagBits depthResolveMode;
3751     VkResolveModeFlagBits stencilResolveMode;
3752     PTR32 pDepthStencilResolveAttachment;
3753 } VkSubpassDescriptionDepthStencilResolve32;
3754 typedef VkSubpassDescriptionDepthStencilResolve32 VkSubpassDescriptionDepthStencilResolveKHR32;
3755
3756 typedef struct VkFragmentShadingRateAttachmentInfoKHR32
3757 {
3758     VkStructureType sType;
3759     PTR32 pNext;
3760     PTR32 pFragmentShadingRateAttachment;
3761     VkExtent2D shadingRateAttachmentTexelSize;
3762 } VkFragmentShadingRateAttachmentInfoKHR32;
3763
3764 typedef struct VkRenderPassCreationControlEXT32
3765 {
3766     VkStructureType sType;
3767     PTR32 pNext;
3768     VkBool32 disallowMerging;
3769 } VkRenderPassCreationControlEXT32;
3770
3771 typedef struct VkRenderPassSubpassFeedbackCreateInfoEXT32
3772 {
3773     VkStructureType sType;
3774     PTR32 pNext;
3775     PTR32 pSubpassFeedback;
3776 } VkRenderPassSubpassFeedbackCreateInfoEXT32;
3777
3778 typedef struct VkSubpassDescription232
3779 {
3780     VkStructureType sType;
3781     PTR32 pNext;
3782     VkSubpassDescriptionFlags flags;
3783     VkPipelineBindPoint pipelineBindPoint;
3784     uint32_t viewMask;
3785     uint32_t inputAttachmentCount;
3786     PTR32 pInputAttachments;
3787     uint32_t colorAttachmentCount;
3788     PTR32 pColorAttachments;
3789     PTR32 pResolveAttachments;
3790     PTR32 pDepthStencilAttachment;
3791     uint32_t preserveAttachmentCount;
3792     PTR32 pPreserveAttachments;
3793 } VkSubpassDescription232;
3794 typedef VkSubpassDescription232 VkSubpassDescription2KHR32;
3795
3796 typedef struct VkSubpassDependency232
3797 {
3798     VkStructureType sType;
3799     PTR32 pNext;
3800     uint32_t srcSubpass;
3801     uint32_t dstSubpass;
3802     VkPipelineStageFlags srcStageMask;
3803     VkPipelineStageFlags dstStageMask;
3804     VkAccessFlags srcAccessMask;
3805     VkAccessFlags dstAccessMask;
3806     VkDependencyFlags dependencyFlags;
3807     int32_t viewOffset;
3808 } VkSubpassDependency232;
3809 typedef VkSubpassDependency232 VkSubpassDependency2KHR32;
3810
3811 typedef struct VkRenderPassCreationFeedbackCreateInfoEXT32
3812 {
3813     VkStructureType sType;
3814     PTR32 pNext;
3815     PTR32 pRenderPassFeedback;
3816 } VkRenderPassCreationFeedbackCreateInfoEXT32;
3817
3818 typedef struct VkRenderPassCreateInfo232
3819 {
3820     VkStructureType sType;
3821     PTR32 pNext;
3822     VkRenderPassCreateFlags flags;
3823     uint32_t attachmentCount;
3824     PTR32 pAttachments;
3825     uint32_t subpassCount;
3826     PTR32 pSubpasses;
3827     uint32_t dependencyCount;
3828     PTR32 pDependencies;
3829     uint32_t correlatedViewMaskCount;
3830     PTR32 pCorrelatedViewMasks;
3831 } VkRenderPassCreateInfo232;
3832 typedef VkRenderPassCreateInfo232 VkRenderPassCreateInfo2KHR32;
3833
3834 typedef struct VkSamplerReductionModeCreateInfo32
3835 {
3836     VkStructureType sType;
3837     PTR32 pNext;
3838     VkSamplerReductionMode reductionMode;
3839 } VkSamplerReductionModeCreateInfo32;
3840 typedef VkSamplerReductionModeCreateInfo32 VkSamplerReductionModeCreateInfoEXT32;
3841
3842 typedef struct VkSamplerCustomBorderColorCreateInfoEXT32
3843 {
3844     VkStructureType sType;
3845     PTR32 pNext;
3846     VkClearColorValue customBorderColor;
3847     VkFormat format;
3848 } VkSamplerCustomBorderColorCreateInfoEXT32;
3849
3850 typedef struct VkSamplerBorderColorComponentMappingCreateInfoEXT32
3851 {
3852     VkStructureType sType;
3853     PTR32 pNext;
3854     VkComponentMapping components;
3855     VkBool32 srgb;
3856 } VkSamplerBorderColorComponentMappingCreateInfoEXT32;
3857
3858 typedef struct VkSamplerCreateInfo32
3859 {
3860     VkStructureType sType;
3861     PTR32 pNext;
3862     VkSamplerCreateFlags flags;
3863     VkFilter magFilter;
3864     VkFilter minFilter;
3865     VkSamplerMipmapMode mipmapMode;
3866     VkSamplerAddressMode addressModeU;
3867     VkSamplerAddressMode addressModeV;
3868     VkSamplerAddressMode addressModeW;
3869     float mipLodBias;
3870     VkBool32 anisotropyEnable;
3871     float maxAnisotropy;
3872     VkBool32 compareEnable;
3873     VkCompareOp compareOp;
3874     float minLod;
3875     float maxLod;
3876     VkBorderColor borderColor;
3877     VkBool32 unnormalizedCoordinates;
3878 } VkSamplerCreateInfo32;
3879
3880 typedef struct VkSamplerYcbcrConversionCreateInfo32
3881 {
3882     VkStructureType sType;
3883     PTR32 pNext;
3884     VkFormat format;
3885     VkSamplerYcbcrModelConversion ycbcrModel;
3886     VkSamplerYcbcrRange ycbcrRange;
3887     VkComponentMapping components;
3888     VkChromaLocation xChromaOffset;
3889     VkChromaLocation yChromaOffset;
3890     VkFilter chromaFilter;
3891     VkBool32 forceExplicitReconstruction;
3892 } VkSamplerYcbcrConversionCreateInfo32;
3893 typedef VkSamplerYcbcrConversionCreateInfo32 VkSamplerYcbcrConversionCreateInfoKHR32;
3894
3895 typedef struct VkExportSemaphoreCreateInfo32
3896 {
3897     VkStructureType sType;
3898     PTR32 pNext;
3899     VkExternalSemaphoreHandleTypeFlags handleTypes;
3900 } VkExportSemaphoreCreateInfo32;
3901 typedef VkExportSemaphoreCreateInfo32 VkExportSemaphoreCreateInfoKHR32;
3902
3903 typedef struct VkSemaphoreTypeCreateInfo32
3904 {
3905     VkStructureType sType;
3906     PTR32 pNext;
3907     VkSemaphoreType semaphoreType;
3908     uint64_t DECLSPEC_ALIGN(8) initialValue;
3909 } VkSemaphoreTypeCreateInfo32;
3910 typedef VkSemaphoreTypeCreateInfo32 VkSemaphoreTypeCreateInfoKHR32;
3911
3912 typedef struct VkQueryLowLatencySupportNV32
3913 {
3914     VkStructureType sType;
3915     PTR32 pNext;
3916     PTR32 pQueriedLowLatencyData;
3917 } VkQueryLowLatencySupportNV32;
3918
3919 typedef struct VkSemaphoreCreateInfo32
3920 {
3921     VkStructureType sType;
3922     PTR32 pNext;
3923     VkSemaphoreCreateFlags flags;
3924 } VkSemaphoreCreateInfo32;
3925
3926 typedef struct VkShaderCreateInfoEXT32
3927 {
3928     VkStructureType sType;
3929     PTR32 pNext;
3930     VkShaderCreateFlagsEXT flags;
3931     VkShaderStageFlagBits stage;
3932     VkShaderStageFlags nextStage;
3933     VkShaderCodeTypeEXT codeType;
3934     PTR32 codeSize;
3935     PTR32 pCode;
3936     PTR32 pName;
3937     uint32_t setLayoutCount;
3938     PTR32 pSetLayouts;
3939     uint32_t pushConstantRangeCount;
3940     PTR32 pPushConstantRanges;
3941     PTR32 pSpecializationInfo;
3942 } VkShaderCreateInfoEXT32;
3943
3944 typedef struct VkDeviceGroupSwapchainCreateInfoKHR32
3945 {
3946     VkStructureType sType;
3947     PTR32 pNext;
3948     VkDeviceGroupPresentModeFlagsKHR modes;
3949 } VkDeviceGroupSwapchainCreateInfoKHR32;
3950
3951 typedef struct VkSwapchainPresentBarrierCreateInfoNV32
3952 {
3953     VkStructureType sType;
3954     PTR32 pNext;
3955     VkBool32 presentBarrierEnable;
3956 } VkSwapchainPresentBarrierCreateInfoNV32;
3957
3958 typedef struct VkSwapchainPresentModesCreateInfoEXT32
3959 {
3960     VkStructureType sType;
3961     PTR32 pNext;
3962     uint32_t presentModeCount;
3963     PTR32 pPresentModes;
3964 } VkSwapchainPresentModesCreateInfoEXT32;
3965
3966 typedef struct VkSwapchainPresentScalingCreateInfoEXT32
3967 {
3968     VkStructureType sType;
3969     PTR32 pNext;
3970     VkPresentScalingFlagsEXT scalingBehavior;
3971     VkPresentGravityFlagsEXT presentGravityX;
3972     VkPresentGravityFlagsEXT presentGravityY;
3973 } VkSwapchainPresentScalingCreateInfoEXT32;
3974
3975 typedef struct VkSwapchainCreateInfoKHR32
3976 {
3977     VkStructureType sType;
3978     PTR32 pNext;
3979     VkSwapchainCreateFlagsKHR flags;
3980     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
3981     uint32_t minImageCount;
3982     VkFormat imageFormat;
3983     VkColorSpaceKHR imageColorSpace;
3984     VkExtent2D imageExtent;
3985     uint32_t imageArrayLayers;
3986     VkImageUsageFlags imageUsage;
3987     VkSharingMode imageSharingMode;
3988     uint32_t queueFamilyIndexCount;
3989     PTR32 pQueueFamilyIndices;
3990     VkSurfaceTransformFlagBitsKHR preTransform;
3991     VkCompositeAlphaFlagBitsKHR compositeAlpha;
3992     VkPresentModeKHR presentMode;
3993     VkBool32 clipped;
3994     VkSwapchainKHR DECLSPEC_ALIGN(8) oldSwapchain;
3995 } VkSwapchainCreateInfoKHR32;
3996
3997 typedef struct VkValidationCacheCreateInfoEXT32
3998 {
3999     VkStructureType sType;
4000     PTR32 pNext;
4001     VkValidationCacheCreateFlagsEXT flags;
4002     PTR32 initialDataSize;
4003     PTR32 pInitialData;
4004 } VkValidationCacheCreateInfoEXT32;
4005
4006 typedef struct VkWin32SurfaceCreateInfoKHR32
4007 {
4008     VkStructureType sType;
4009     PTR32 pNext;
4010     VkWin32SurfaceCreateFlagsKHR flags;
4011     PTR32 hinstance;
4012     PTR32 hwnd;
4013 } VkWin32SurfaceCreateInfoKHR32;
4014
4015 typedef struct VkDebugMarkerObjectNameInfoEXT32
4016 {
4017     VkStructureType sType;
4018     PTR32 pNext;
4019     VkDebugReportObjectTypeEXT objectType;
4020     uint64_t DECLSPEC_ALIGN(8) object;
4021     PTR32 pObjectName;
4022 } VkDebugMarkerObjectNameInfoEXT32;
4023
4024 typedef struct VkDebugMarkerObjectTagInfoEXT32
4025 {
4026     VkStructureType sType;
4027     PTR32 pNext;
4028     VkDebugReportObjectTypeEXT objectType;
4029     uint64_t DECLSPEC_ALIGN(8) object;
4030     uint64_t DECLSPEC_ALIGN(8) tagName;
4031     PTR32 tagSize;
4032     PTR32 pTag;
4033 } VkDebugMarkerObjectTagInfoEXT32;
4034
4035 typedef struct VkPhysicalDeviceGroupProperties32
4036 {
4037     VkStructureType sType;
4038     PTR32 pNext;
4039     uint32_t physicalDeviceCount;
4040     PTR32 physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
4041     VkBool32 subsetAllocation;
4042 } VkPhysicalDeviceGroupProperties32;
4043 typedef VkPhysicalDeviceGroupProperties32 VkPhysicalDeviceGroupPropertiesKHR32;
4044
4045 typedef struct VkPerformanceCounterKHR32
4046 {
4047     VkStructureType sType;
4048     PTR32 pNext;
4049     VkPerformanceCounterUnitKHR unit;
4050     VkPerformanceCounterScopeKHR scope;
4051     VkPerformanceCounterStorageKHR storage;
4052     uint8_t uuid[VK_UUID_SIZE];
4053 } VkPerformanceCounterKHR32;
4054
4055 typedef struct VkPerformanceCounterDescriptionKHR32
4056 {
4057     VkStructureType sType;
4058     PTR32 pNext;
4059     VkPerformanceCounterDescriptionFlagsKHR flags;
4060     char name[VK_MAX_DESCRIPTION_SIZE];
4061     char category[VK_MAX_DESCRIPTION_SIZE];
4062     char description[VK_MAX_DESCRIPTION_SIZE];
4063 } VkPerformanceCounterDescriptionKHR32;
4064
4065 typedef struct VkMappedMemoryRange32
4066 {
4067     VkStructureType sType;
4068     PTR32 pNext;
4069     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
4070     VkDeviceSize DECLSPEC_ALIGN(8) offset;
4071     VkDeviceSize DECLSPEC_ALIGN(8) size;
4072 } VkMappedMemoryRange32;
4073
4074 typedef struct VkAccelerationStructureBuildSizesInfoKHR32
4075 {
4076     VkStructureType sType;
4077     PTR32 pNext;
4078     VkDeviceSize DECLSPEC_ALIGN(8) accelerationStructureSize;
4079     VkDeviceSize DECLSPEC_ALIGN(8) updateScratchSize;
4080     VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize;
4081 } VkAccelerationStructureBuildSizesInfoKHR32;
4082
4083 typedef struct VkAccelerationStructureDeviceAddressInfoKHR32
4084 {
4085     VkStructureType sType;
4086     PTR32 pNext;
4087     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
4088 } VkAccelerationStructureDeviceAddressInfoKHR32;
4089
4090 typedef struct VkAccelerationStructureMemoryRequirementsInfoNV32
4091 {
4092     VkStructureType sType;
4093     PTR32 pNext;
4094     VkAccelerationStructureMemoryRequirementsTypeNV type;
4095     VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
4096 } VkAccelerationStructureMemoryRequirementsInfoNV32;
4097
4098 typedef struct VkMemoryRequirements32
4099 {
4100     VkDeviceSize DECLSPEC_ALIGN(8) size;
4101     VkDeviceSize DECLSPEC_ALIGN(8) alignment;
4102     uint32_t memoryTypeBits;
4103 } VkMemoryRequirements32;
4104
4105
4106 typedef struct VkAccelerationStructureCaptureDescriptorDataInfoEXT32
4107 {
4108     VkStructureType sType;
4109     PTR32 pNext;
4110     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
4111     VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructureNV;
4112 } VkAccelerationStructureCaptureDescriptorDataInfoEXT32;
4113
4114 typedef struct VkBufferDeviceAddressInfo32
4115 {
4116     VkStructureType sType;
4117     PTR32 pNext;
4118     VkBuffer DECLSPEC_ALIGN(8) buffer;
4119 } VkBufferDeviceAddressInfo32;
4120 typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoKHR32;
4121 typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoEXT32;
4122
4123 typedef struct VkBufferMemoryRequirementsInfo232
4124 {
4125     VkStructureType sType;
4126     PTR32 pNext;
4127     VkBuffer DECLSPEC_ALIGN(8) buffer;
4128 } VkBufferMemoryRequirementsInfo232;
4129 typedef VkBufferMemoryRequirementsInfo232 VkBufferMemoryRequirementsInfo2KHR32;
4130
4131 typedef struct VkMemoryDedicatedRequirements32
4132 {
4133     VkStructureType sType;
4134     PTR32 pNext;
4135     VkBool32 prefersDedicatedAllocation;
4136     VkBool32 requiresDedicatedAllocation;
4137 } VkMemoryDedicatedRequirements32;
4138 typedef VkMemoryDedicatedRequirements32 VkMemoryDedicatedRequirementsKHR32;
4139
4140 typedef struct VkMemoryRequirements232
4141 {
4142     VkStructureType sType;
4143     PTR32 pNext;
4144     VkMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
4145 } VkMemoryRequirements232;
4146 typedef VkMemoryRequirements232 VkMemoryRequirements2KHR32;
4147
4148 typedef struct VkBufferCaptureDescriptorDataInfoEXT32
4149 {
4150     VkStructureType sType;
4151     PTR32 pNext;
4152     VkBuffer DECLSPEC_ALIGN(8) buffer;
4153 } VkBufferCaptureDescriptorDataInfoEXT32;
4154
4155 typedef struct VkCalibratedTimestampInfoEXT32
4156 {
4157     VkStructureType sType;
4158     PTR32 pNext;
4159     VkTimeDomainEXT timeDomain;
4160 } VkCalibratedTimestampInfoEXT32;
4161
4162 typedef struct VkDescriptorAddressInfoEXT32
4163 {
4164     VkStructureType sType;
4165     PTR32 pNext;
4166     VkDeviceAddress DECLSPEC_ALIGN(8) address;
4167     VkDeviceSize DECLSPEC_ALIGN(8) range;
4168     VkFormat format;
4169 } VkDescriptorAddressInfoEXT32;
4170
4171 typedef union VkDescriptorDataEXT32
4172 {
4173     PTR32 pSampler;
4174     PTR32 pCombinedImageSampler;
4175     PTR32 pInputAttachmentImage;
4176     PTR32 pSampledImage;
4177     PTR32 pStorageImage;
4178     PTR32 pUniformTexelBuffer;
4179     PTR32 pStorageTexelBuffer;
4180     PTR32 pUniformBuffer;
4181     PTR32 pStorageBuffer;
4182     VkDeviceAddress DECLSPEC_ALIGN(8) accelerationStructure;
4183 } VkDescriptorDataEXT32;
4184
4185 typedef struct VkDescriptorGetInfoEXT32
4186 {
4187     VkStructureType sType;
4188     PTR32 pNext;
4189     VkDescriptorType type;
4190     VkDescriptorDataEXT32 DECLSPEC_ALIGN(8) data;
4191 } VkDescriptorGetInfoEXT32;
4192
4193 typedef struct VkDescriptorSetBindingReferenceVALVE32
4194 {
4195     VkStructureType sType;
4196     PTR32 pNext;
4197     VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
4198     uint32_t binding;
4199 } VkDescriptorSetBindingReferenceVALVE32;
4200
4201 typedef struct VkDescriptorSetLayoutHostMappingInfoVALVE32
4202 {
4203     VkStructureType sType;
4204     PTR32 pNext;
4205     PTR32 descriptorOffset;
4206     uint32_t descriptorSize;
4207 } VkDescriptorSetLayoutHostMappingInfoVALVE32;
4208
4209 typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport32
4210 {
4211     VkStructureType sType;
4212     PTR32 pNext;
4213     uint32_t maxVariableDescriptorCount;
4214 } VkDescriptorSetVariableDescriptorCountLayoutSupport32;
4215 typedef VkDescriptorSetVariableDescriptorCountLayoutSupport32 VkDescriptorSetVariableDescriptorCountLayoutSupportEXT32;
4216
4217 typedef struct VkDescriptorSetLayoutSupport32
4218 {
4219     VkStructureType sType;
4220     PTR32 pNext;
4221     VkBool32 supported;
4222 } VkDescriptorSetLayoutSupport32;
4223 typedef VkDescriptorSetLayoutSupport32 VkDescriptorSetLayoutSupportKHR32;
4224
4225 typedef struct VkAccelerationStructureVersionInfoKHR32
4226 {
4227     VkStructureType sType;
4228     PTR32 pNext;
4229     PTR32 pVersionData;
4230 } VkAccelerationStructureVersionInfoKHR32;
4231
4232 typedef struct VkDeviceBufferMemoryRequirements32
4233 {
4234     VkStructureType sType;
4235     PTR32 pNext;
4236     PTR32 pCreateInfo;
4237 } VkDeviceBufferMemoryRequirements32;
4238 typedef VkDeviceBufferMemoryRequirements32 VkDeviceBufferMemoryRequirementsKHR32;
4239
4240 typedef struct VkDeviceFaultCountsEXT32
4241 {
4242     VkStructureType sType;
4243     PTR32 pNext;
4244     uint32_t addressInfoCount;
4245     uint32_t vendorInfoCount;
4246     VkDeviceSize DECLSPEC_ALIGN(8) vendorBinarySize;
4247 } VkDeviceFaultCountsEXT32;
4248
4249 typedef struct VkDeviceFaultAddressInfoEXT32
4250 {
4251     VkDeviceFaultAddressTypeEXT addressType;
4252     VkDeviceAddress DECLSPEC_ALIGN(8) reportedAddress;
4253     VkDeviceSize DECLSPEC_ALIGN(8) addressPrecision;
4254 } VkDeviceFaultAddressInfoEXT32;
4255
4256 typedef struct VkDeviceFaultVendorInfoEXT32
4257 {
4258     char description[VK_MAX_DESCRIPTION_SIZE];
4259     uint64_t DECLSPEC_ALIGN(8) vendorFaultCode;
4260     uint64_t DECLSPEC_ALIGN(8) vendorFaultData;
4261 } VkDeviceFaultVendorInfoEXT32;
4262
4263 typedef struct VkDeviceFaultInfoEXT32
4264 {
4265     VkStructureType sType;
4266     PTR32 pNext;
4267     char description[VK_MAX_DESCRIPTION_SIZE];
4268     PTR32 pAddressInfos;
4269     PTR32 pVendorInfos;
4270     PTR32 pVendorBinaryData;
4271 } VkDeviceFaultInfoEXT32;
4272
4273 typedef struct VkDeviceGroupPresentCapabilitiesKHR32
4274 {
4275     VkStructureType sType;
4276     PTR32 pNext;
4277     uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
4278     VkDeviceGroupPresentModeFlagsKHR modes;
4279 } VkDeviceGroupPresentCapabilitiesKHR32;
4280
4281 typedef struct VkDeviceImageMemoryRequirements32
4282 {
4283     VkStructureType sType;
4284     PTR32 pNext;
4285     PTR32 pCreateInfo;
4286     VkImageAspectFlagBits planeAspect;
4287 } VkDeviceImageMemoryRequirements32;
4288 typedef VkDeviceImageMemoryRequirements32 VkDeviceImageMemoryRequirementsKHR32;
4289
4290 typedef struct VkSparseImageMemoryRequirements32
4291 {
4292     VkSparseImageFormatProperties formatProperties;
4293     uint32_t imageMipTailFirstLod;
4294     VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailSize;
4295     VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailOffset;
4296     VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailStride;
4297 } VkSparseImageMemoryRequirements32;
4298
4299 typedef struct VkSparseImageMemoryRequirements232
4300 {
4301     VkStructureType sType;
4302     PTR32 pNext;
4303     VkSparseImageMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
4304 } VkSparseImageMemoryRequirements232;
4305 typedef VkSparseImageMemoryRequirements232 VkSparseImageMemoryRequirements2KHR32;
4306
4307 typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo32
4308 {
4309     VkStructureType sType;
4310     PTR32 pNext;
4311     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
4312 } VkDeviceMemoryOpaqueCaptureAddressInfo32;
4313 typedef VkDeviceMemoryOpaqueCaptureAddressInfo32 VkDeviceMemoryOpaqueCaptureAddressInfoKHR32;
4314
4315 typedef struct VkMicromapVersionInfoEXT32
4316 {
4317     VkStructureType sType;
4318     PTR32 pNext;
4319     PTR32 pVersionData;
4320 } VkMicromapVersionInfoEXT32;
4321
4322 typedef struct VkDeviceQueueInfo232
4323 {
4324     VkStructureType sType;
4325     PTR32 pNext;
4326     VkDeviceQueueCreateFlags flags;
4327     uint32_t queueFamilyIndex;
4328     uint32_t queueIndex;
4329 } VkDeviceQueueInfo232;
4330
4331 typedef struct VkTilePropertiesQCOM32
4332 {
4333     VkStructureType sType;
4334     PTR32 pNext;
4335     VkExtent3D tileSize;
4336     VkExtent2D apronSize;
4337     VkOffset2D origin;
4338 } VkTilePropertiesQCOM32;
4339
4340 typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV32
4341 {
4342     VkStructureType sType;
4343     PTR32 pNext;
4344     VkPipelineBindPoint pipelineBindPoint;
4345     VkPipeline DECLSPEC_ALIGN(8) pipeline;
4346     VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
4347     uint32_t maxSequencesCount;
4348 } VkGeneratedCommandsMemoryRequirementsInfoNV32;
4349
4350 typedef struct VkImagePlaneMemoryRequirementsInfo32
4351 {
4352     VkStructureType sType;
4353     PTR32 pNext;
4354     VkImageAspectFlagBits planeAspect;
4355 } VkImagePlaneMemoryRequirementsInfo32;
4356 typedef VkImagePlaneMemoryRequirementsInfo32 VkImagePlaneMemoryRequirementsInfoKHR32;
4357
4358 typedef struct VkImageMemoryRequirementsInfo232
4359 {
4360     VkStructureType sType;
4361     PTR32 pNext;
4362     VkImage DECLSPEC_ALIGN(8) image;
4363 } VkImageMemoryRequirementsInfo232;
4364 typedef VkImageMemoryRequirementsInfo232 VkImageMemoryRequirementsInfo2KHR32;
4365
4366 typedef struct VkImageCaptureDescriptorDataInfoEXT32
4367 {
4368     VkStructureType sType;
4369     PTR32 pNext;
4370     VkImage DECLSPEC_ALIGN(8) image;
4371 } VkImageCaptureDescriptorDataInfoEXT32;
4372
4373 typedef struct VkImageSparseMemoryRequirementsInfo232
4374 {
4375     VkStructureType sType;
4376     PTR32 pNext;
4377     VkImage DECLSPEC_ALIGN(8) image;
4378 } VkImageSparseMemoryRequirementsInfo232;
4379 typedef VkImageSparseMemoryRequirementsInfo232 VkImageSparseMemoryRequirementsInfo2KHR32;
4380
4381 typedef struct VkSubresourceLayout32
4382 {
4383     VkDeviceSize DECLSPEC_ALIGN(8) offset;
4384     VkDeviceSize DECLSPEC_ALIGN(8) size;
4385     VkDeviceSize DECLSPEC_ALIGN(8) rowPitch;
4386     VkDeviceSize DECLSPEC_ALIGN(8) arrayPitch;
4387     VkDeviceSize DECLSPEC_ALIGN(8) depthPitch;
4388 } VkSubresourceLayout32;
4389
4390 typedef struct VkImageSubresource2EXT32
4391 {
4392     VkStructureType sType;
4393     PTR32 pNext;
4394     VkImageSubresource imageSubresource;
4395 } VkImageSubresource2EXT32;
4396
4397 typedef struct VkImageCompressionPropertiesEXT32
4398 {
4399     VkStructureType sType;
4400     PTR32 pNext;
4401     VkImageCompressionFlagsEXT imageCompressionFlags;
4402     VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags;
4403 } VkImageCompressionPropertiesEXT32;
4404
4405 typedef struct VkSubresourceLayout2EXT32
4406 {
4407     VkStructureType sType;
4408     PTR32 pNext;
4409     VkSubresourceLayout32 DECLSPEC_ALIGN(8) subresourceLayout;
4410 } VkSubresourceLayout2EXT32;
4411
4412 typedef struct VkImageViewAddressPropertiesNVX32
4413 {
4414     VkStructureType sType;
4415     PTR32 pNext;
4416     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
4417     VkDeviceSize DECLSPEC_ALIGN(8) size;
4418 } VkImageViewAddressPropertiesNVX32;
4419
4420 typedef struct VkImageViewHandleInfoNVX32
4421 {
4422     VkStructureType sType;
4423     PTR32 pNext;
4424     VkImageView DECLSPEC_ALIGN(8) imageView;
4425     VkDescriptorType descriptorType;
4426     VkSampler DECLSPEC_ALIGN(8) sampler;
4427 } VkImageViewHandleInfoNVX32;
4428
4429 typedef struct VkImageViewCaptureDescriptorDataInfoEXT32
4430 {
4431     VkStructureType sType;
4432     PTR32 pNext;
4433     VkImageView DECLSPEC_ALIGN(8) imageView;
4434 } VkImageViewCaptureDescriptorDataInfoEXT32;
4435
4436 typedef struct VkMemoryHostPointerPropertiesEXT32
4437 {
4438     VkStructureType sType;
4439     PTR32 pNext;
4440     uint32_t memoryTypeBits;
4441 } VkMemoryHostPointerPropertiesEXT32;
4442
4443 typedef struct VkMicromapBuildSizesInfoEXT32
4444 {
4445     VkStructureType sType;
4446     PTR32 pNext;
4447     VkDeviceSize DECLSPEC_ALIGN(8) micromapSize;
4448     VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize;
4449     VkBool32 discardable;
4450 } VkMicromapBuildSizesInfoEXT32;
4451
4452 typedef union VkPerformanceValueDataINTEL32
4453 {
4454     uint32_t value32;
4455     uint64_t DECLSPEC_ALIGN(8) value64;
4456     float valueFloat;
4457     VkBool32 valueBool;
4458     PTR32 valueString;
4459 } VkPerformanceValueDataINTEL32;
4460
4461 typedef struct VkPerformanceValueINTEL32
4462 {
4463     VkPerformanceValueTypeINTEL type;
4464     VkPerformanceValueDataINTEL32 DECLSPEC_ALIGN(8) data;
4465 } VkPerformanceValueINTEL32;
4466
4467 typedef struct VkCooperativeMatrixPropertiesNV32
4468 {
4469     VkStructureType sType;
4470     PTR32 pNext;
4471     uint32_t MSize;
4472     uint32_t NSize;
4473     uint32_t KSize;
4474     VkComponentTypeNV AType;
4475     VkComponentTypeNV BType;
4476     VkComponentTypeNV CType;
4477     VkComponentTypeNV DType;
4478     VkScopeNV scope;
4479 } VkCooperativeMatrixPropertiesNV32;
4480
4481 typedef struct VkPhysicalDeviceExternalBufferInfo32
4482 {
4483     VkStructureType sType;
4484     PTR32 pNext;
4485     VkBufferCreateFlags flags;
4486     VkBufferUsageFlags usage;
4487     VkExternalMemoryHandleTypeFlagBits handleType;
4488 } VkPhysicalDeviceExternalBufferInfo32;
4489 typedef VkPhysicalDeviceExternalBufferInfo32 VkPhysicalDeviceExternalBufferInfoKHR32;
4490
4491 typedef struct VkExternalBufferProperties32
4492 {
4493     VkStructureType sType;
4494     PTR32 pNext;
4495     VkExternalMemoryProperties externalMemoryProperties;
4496 } VkExternalBufferProperties32;
4497 typedef VkExternalBufferProperties32 VkExternalBufferPropertiesKHR32;
4498
4499 typedef struct VkPhysicalDeviceExternalFenceInfo32
4500 {
4501     VkStructureType sType;
4502     PTR32 pNext;
4503     VkExternalFenceHandleTypeFlagBits handleType;
4504 } VkPhysicalDeviceExternalFenceInfo32;
4505 typedef VkPhysicalDeviceExternalFenceInfo32 VkPhysicalDeviceExternalFenceInfoKHR32;
4506
4507 typedef struct VkExternalFenceProperties32
4508 {
4509     VkStructureType sType;
4510     PTR32 pNext;
4511     VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
4512     VkExternalFenceHandleTypeFlags compatibleHandleTypes;
4513     VkExternalFenceFeatureFlags externalFenceFeatures;
4514 } VkExternalFenceProperties32;
4515 typedef VkExternalFenceProperties32 VkExternalFencePropertiesKHR32;
4516
4517 typedef struct VkPhysicalDeviceExternalSemaphoreInfo32
4518 {
4519     VkStructureType sType;
4520     PTR32 pNext;
4521     VkExternalSemaphoreHandleTypeFlagBits handleType;
4522 } VkPhysicalDeviceExternalSemaphoreInfo32;
4523 typedef VkPhysicalDeviceExternalSemaphoreInfo32 VkPhysicalDeviceExternalSemaphoreInfoKHR32;
4524
4525 typedef struct VkExternalSemaphoreProperties32
4526 {
4527     VkStructureType sType;
4528     PTR32 pNext;
4529     VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
4530     VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
4531     VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
4532 } VkExternalSemaphoreProperties32;
4533 typedef VkExternalSemaphoreProperties32 VkExternalSemaphorePropertiesKHR32;
4534
4535 typedef struct VkSubpassResolvePerformanceQueryEXT32
4536 {
4537     VkStructureType sType;
4538     PTR32 pNext;
4539     VkBool32 optimal;
4540 } VkSubpassResolvePerformanceQueryEXT32;
4541
4542 typedef struct VkFormatProperties332
4543 {
4544     VkStructureType sType;
4545     PTR32 pNext;
4546     VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) linearTilingFeatures;
4547     VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) optimalTilingFeatures;
4548     VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) bufferFeatures;
4549 } VkFormatProperties332;
4550 typedef VkFormatProperties332 VkFormatProperties3KHR32;
4551
4552 typedef struct VkFormatProperties232
4553 {
4554     VkStructureType sType;
4555     PTR32 pNext;
4556     VkFormatProperties formatProperties;
4557 } VkFormatProperties232;
4558 typedef VkFormatProperties232 VkFormatProperties2KHR32;
4559
4560 typedef struct VkPhysicalDeviceFragmentShadingRateKHR32
4561 {
4562     VkStructureType sType;
4563     PTR32 pNext;
4564     VkSampleCountFlags sampleCounts;
4565     VkExtent2D fragmentSize;
4566 } VkPhysicalDeviceFragmentShadingRateKHR32;
4567
4568 typedef struct VkImageFormatProperties32
4569 {
4570     VkExtent3D maxExtent;
4571     uint32_t maxMipLevels;
4572     uint32_t maxArrayLayers;
4573     VkSampleCountFlags sampleCounts;
4574     VkDeviceSize DECLSPEC_ALIGN(8) maxResourceSize;
4575 } VkImageFormatProperties32;
4576
4577 typedef struct VkPhysicalDeviceExternalImageFormatInfo32
4578 {
4579     VkStructureType sType;
4580     PTR32 pNext;
4581     VkExternalMemoryHandleTypeFlagBits handleType;
4582 } VkPhysicalDeviceExternalImageFormatInfo32;
4583 typedef VkPhysicalDeviceExternalImageFormatInfo32 VkPhysicalDeviceExternalImageFormatInfoKHR32;
4584
4585 typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT32
4586 {
4587     VkStructureType sType;
4588     PTR32 pNext;
4589     VkImageViewType imageViewType;
4590 } VkPhysicalDeviceImageViewImageFormatInfoEXT32;
4591
4592 typedef struct VkPhysicalDeviceImageFormatInfo232
4593 {
4594     VkStructureType sType;
4595     PTR32 pNext;
4596     VkFormat format;
4597     VkImageType type;
4598     VkImageTiling tiling;
4599     VkImageUsageFlags usage;
4600     VkImageCreateFlags flags;
4601 } VkPhysicalDeviceImageFormatInfo232;
4602 typedef VkPhysicalDeviceImageFormatInfo232 VkPhysicalDeviceImageFormatInfo2KHR32;
4603
4604 typedef struct VkExternalImageFormatProperties32
4605 {
4606     VkStructureType sType;
4607     PTR32 pNext;
4608     VkExternalMemoryProperties externalMemoryProperties;
4609 } VkExternalImageFormatProperties32;
4610 typedef VkExternalImageFormatProperties32 VkExternalImageFormatPropertiesKHR32;
4611
4612 typedef struct VkSamplerYcbcrConversionImageFormatProperties32
4613 {
4614     VkStructureType sType;
4615     PTR32 pNext;
4616     uint32_t combinedImageSamplerDescriptorCount;
4617 } VkSamplerYcbcrConversionImageFormatProperties32;
4618 typedef VkSamplerYcbcrConversionImageFormatProperties32 VkSamplerYcbcrConversionImageFormatPropertiesKHR32;
4619
4620 typedef struct VkTextureLODGatherFormatPropertiesAMD32
4621 {
4622     VkStructureType sType;
4623     PTR32 pNext;
4624     VkBool32 supportsTextureGatherLODBiasAMD;
4625 } VkTextureLODGatherFormatPropertiesAMD32;
4626
4627 typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT32
4628 {
4629     VkStructureType sType;
4630     PTR32 pNext;
4631     VkBool32 filterCubic;
4632     VkBool32 filterCubicMinmax;
4633 } VkFilterCubicImageViewImageFormatPropertiesEXT32;
4634
4635 typedef struct VkImageFormatProperties232
4636 {
4637     VkStructureType sType;
4638     PTR32 pNext;
4639     VkImageFormatProperties32 DECLSPEC_ALIGN(8) imageFormatProperties;
4640 } VkImageFormatProperties232;
4641 typedef VkImageFormatProperties232 VkImageFormatProperties2KHR32;
4642
4643 typedef struct VkMemoryHeap32
4644 {
4645     VkDeviceSize DECLSPEC_ALIGN(8) size;
4646     VkMemoryHeapFlags flags;
4647 } VkMemoryHeap32;
4648
4649 typedef struct VkPhysicalDeviceMemoryProperties32
4650 {
4651     uint32_t memoryTypeCount;
4652     VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
4653     uint32_t memoryHeapCount;
4654     VkMemoryHeap32 DECLSPEC_ALIGN(8) memoryHeaps[VK_MAX_MEMORY_HEAPS];
4655 } VkPhysicalDeviceMemoryProperties32;
4656
4657 typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT32
4658 {
4659     VkStructureType sType;
4660     PTR32 pNext;
4661     VkDeviceSize DECLSPEC_ALIGN(8) heapBudget[VK_MAX_MEMORY_HEAPS];
4662     VkDeviceSize DECLSPEC_ALIGN(8) heapUsage[VK_MAX_MEMORY_HEAPS];
4663 } VkPhysicalDeviceMemoryBudgetPropertiesEXT32;
4664
4665 typedef struct VkPhysicalDeviceMemoryProperties232
4666 {
4667     VkStructureType sType;
4668     PTR32 pNext;
4669     VkPhysicalDeviceMemoryProperties32 DECLSPEC_ALIGN(8) memoryProperties;
4670 } VkPhysicalDeviceMemoryProperties232;
4671 typedef VkPhysicalDeviceMemoryProperties232 VkPhysicalDeviceMemoryProperties2KHR32;
4672
4673 typedef struct VkMultisamplePropertiesEXT32
4674 {
4675     VkStructureType sType;
4676     PTR32 pNext;
4677     VkExtent2D maxSampleLocationGridSize;
4678 } VkMultisamplePropertiesEXT32;
4679
4680 typedef struct VkOpticalFlowImageFormatPropertiesNV32
4681 {
4682     VkStructureType sType;
4683     PTR32 pNext;
4684     VkFormat format;
4685 } VkOpticalFlowImageFormatPropertiesNV32;
4686
4687 typedef struct VkPhysicalDeviceLimits32
4688 {
4689     uint32_t maxImageDimension1D;
4690     uint32_t maxImageDimension2D;
4691     uint32_t maxImageDimension3D;
4692     uint32_t maxImageDimensionCube;
4693     uint32_t maxImageArrayLayers;
4694     uint32_t maxTexelBufferElements;
4695     uint32_t maxUniformBufferRange;
4696     uint32_t maxStorageBufferRange;
4697     uint32_t maxPushConstantsSize;
4698     uint32_t maxMemoryAllocationCount;
4699     uint32_t maxSamplerAllocationCount;
4700     VkDeviceSize DECLSPEC_ALIGN(8) bufferImageGranularity;
4701     VkDeviceSize DECLSPEC_ALIGN(8) sparseAddressSpaceSize;
4702     uint32_t maxBoundDescriptorSets;
4703     uint32_t maxPerStageDescriptorSamplers;
4704     uint32_t maxPerStageDescriptorUniformBuffers;
4705     uint32_t maxPerStageDescriptorStorageBuffers;
4706     uint32_t maxPerStageDescriptorSampledImages;
4707     uint32_t maxPerStageDescriptorStorageImages;
4708     uint32_t maxPerStageDescriptorInputAttachments;
4709     uint32_t maxPerStageResources;
4710     uint32_t maxDescriptorSetSamplers;
4711     uint32_t maxDescriptorSetUniformBuffers;
4712     uint32_t maxDescriptorSetUniformBuffersDynamic;
4713     uint32_t maxDescriptorSetStorageBuffers;
4714     uint32_t maxDescriptorSetStorageBuffersDynamic;
4715     uint32_t maxDescriptorSetSampledImages;
4716     uint32_t maxDescriptorSetStorageImages;
4717     uint32_t maxDescriptorSetInputAttachments;
4718     uint32_t maxVertexInputAttributes;
4719     uint32_t maxVertexInputBindings;
4720     uint32_t maxVertexInputAttributeOffset;
4721     uint32_t maxVertexInputBindingStride;
4722     uint32_t maxVertexOutputComponents;
4723     uint32_t maxTessellationGenerationLevel;
4724     uint32_t maxTessellationPatchSize;
4725     uint32_t maxTessellationControlPerVertexInputComponents;
4726     uint32_t maxTessellationControlPerVertexOutputComponents;
4727     uint32_t maxTessellationControlPerPatchOutputComponents;
4728     uint32_t maxTessellationControlTotalOutputComponents;
4729     uint32_t maxTessellationEvaluationInputComponents;
4730     uint32_t maxTessellationEvaluationOutputComponents;
4731     uint32_t maxGeometryShaderInvocations;
4732     uint32_t maxGeometryInputComponents;
4733     uint32_t maxGeometryOutputComponents;
4734     uint32_t maxGeometryOutputVertices;
4735     uint32_t maxGeometryTotalOutputComponents;
4736     uint32_t maxFragmentInputComponents;
4737     uint32_t maxFragmentOutputAttachments;
4738     uint32_t maxFragmentDualSrcAttachments;
4739     uint32_t maxFragmentCombinedOutputResources;
4740     uint32_t maxComputeSharedMemorySize;
4741     uint32_t maxComputeWorkGroupCount[3];
4742     uint32_t maxComputeWorkGroupInvocations;
4743     uint32_t maxComputeWorkGroupSize[3];
4744     uint32_t subPixelPrecisionBits;
4745     uint32_t subTexelPrecisionBits;
4746     uint32_t mipmapPrecisionBits;
4747     uint32_t maxDrawIndexedIndexValue;
4748     uint32_t maxDrawIndirectCount;
4749     float maxSamplerLodBias;
4750     float maxSamplerAnisotropy;
4751     uint32_t maxViewports;
4752     uint32_t maxViewportDimensions[2];
4753     float viewportBoundsRange[2];
4754     uint32_t viewportSubPixelBits;
4755     PTR32 minMemoryMapAlignment;
4756     VkDeviceSize DECLSPEC_ALIGN(8) minTexelBufferOffsetAlignment;
4757     VkDeviceSize DECLSPEC_ALIGN(8) minUniformBufferOffsetAlignment;
4758     VkDeviceSize DECLSPEC_ALIGN(8) minStorageBufferOffsetAlignment;
4759     int32_t minTexelOffset;
4760     uint32_t maxTexelOffset;
4761     int32_t minTexelGatherOffset;
4762     uint32_t maxTexelGatherOffset;
4763     float minInterpolationOffset;
4764     float maxInterpolationOffset;
4765     uint32_t subPixelInterpolationOffsetBits;
4766     uint32_t maxFramebufferWidth;
4767     uint32_t maxFramebufferHeight;
4768     uint32_t maxFramebufferLayers;
4769     VkSampleCountFlags framebufferColorSampleCounts;
4770     VkSampleCountFlags framebufferDepthSampleCounts;
4771     VkSampleCountFlags framebufferStencilSampleCounts;
4772     VkSampleCountFlags framebufferNoAttachmentsSampleCounts;
4773     uint32_t maxColorAttachments;
4774     VkSampleCountFlags sampledImageColorSampleCounts;
4775     VkSampleCountFlags sampledImageIntegerSampleCounts;
4776     VkSampleCountFlags sampledImageDepthSampleCounts;
4777     VkSampleCountFlags sampledImageStencilSampleCounts;
4778     VkSampleCountFlags storageImageSampleCounts;
4779     uint32_t maxSampleMaskWords;
4780     VkBool32 timestampComputeAndGraphics;
4781     float timestampPeriod;
4782     uint32_t maxClipDistances;
4783     uint32_t maxCullDistances;
4784     uint32_t maxCombinedClipAndCullDistances;
4785     uint32_t discreteQueuePriorities;
4786     float pointSizeRange[2];
4787     float lineWidthRange[2];
4788     float pointSizeGranularity;
4789     float lineWidthGranularity;
4790     VkBool32 strictLines;
4791     VkBool32 standardSampleLocations;
4792     VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyOffsetAlignment;
4793     VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyRowPitchAlignment;
4794     VkDeviceSize DECLSPEC_ALIGN(8) nonCoherentAtomSize;
4795 } VkPhysicalDeviceLimits32;
4796
4797 typedef struct VkPhysicalDeviceProperties32
4798 {
4799     uint32_t apiVersion;
4800     uint32_t driverVersion;
4801     uint32_t vendorID;
4802     uint32_t deviceID;
4803     VkPhysicalDeviceType deviceType;
4804     char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
4805     uint8_t pipelineCacheUUID[VK_UUID_SIZE];
4806     VkPhysicalDeviceLimits32 DECLSPEC_ALIGN(8) limits;
4807     VkPhysicalDeviceSparseProperties sparseProperties;
4808 } VkPhysicalDeviceProperties32;
4809
4810 typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32
4811 {
4812     VkStructureType sType;
4813     PTR32 pNext;
4814     uint32_t maxGraphicsShaderGroupCount;
4815     uint32_t maxIndirectSequenceCount;
4816     uint32_t maxIndirectCommandsTokenCount;
4817     uint32_t maxIndirectCommandsStreamCount;
4818     uint32_t maxIndirectCommandsTokenOffset;
4819     uint32_t maxIndirectCommandsStreamStride;
4820     uint32_t minSequencesCountBufferOffsetAlignment;
4821     uint32_t minSequencesIndexBufferOffsetAlignment;
4822     uint32_t minIndirectCommandsBufferOffsetAlignment;
4823 } VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32;
4824
4825 typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT32
4826 {
4827     VkStructureType sType;
4828     PTR32 pNext;
4829     uint32_t maxMultiDrawCount;
4830 } VkPhysicalDeviceMultiDrawPropertiesEXT32;
4831
4832 typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR32
4833 {
4834     VkStructureType sType;
4835     PTR32 pNext;
4836     uint32_t maxPushDescriptors;
4837 } VkPhysicalDevicePushDescriptorPropertiesKHR32;
4838
4839 typedef struct VkPhysicalDeviceDriverProperties32
4840 {
4841     VkStructureType sType;
4842     PTR32 pNext;
4843     VkDriverId driverID;
4844     char driverName[VK_MAX_DRIVER_NAME_SIZE];
4845     char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
4846     VkConformanceVersion conformanceVersion;
4847 } VkPhysicalDeviceDriverProperties32;
4848 typedef VkPhysicalDeviceDriverProperties32 VkPhysicalDeviceDriverPropertiesKHR32;
4849
4850 typedef struct VkPhysicalDeviceIDProperties32
4851 {
4852     VkStructureType sType;
4853     PTR32 pNext;
4854     uint8_t deviceUUID[VK_UUID_SIZE];
4855     uint8_t driverUUID[VK_UUID_SIZE];
4856     uint8_t deviceLUID[VK_LUID_SIZE];
4857     uint32_t deviceNodeMask;
4858     VkBool32 deviceLUIDValid;
4859 } VkPhysicalDeviceIDProperties32;
4860 typedef VkPhysicalDeviceIDProperties32 VkPhysicalDeviceIDPropertiesKHR32;
4861
4862 typedef struct VkPhysicalDeviceMultiviewProperties32
4863 {
4864     VkStructureType sType;
4865     PTR32 pNext;
4866     uint32_t maxMultiviewViewCount;
4867     uint32_t maxMultiviewInstanceIndex;
4868 } VkPhysicalDeviceMultiviewProperties32;
4869 typedef VkPhysicalDeviceMultiviewProperties32 VkPhysicalDeviceMultiviewPropertiesKHR32;
4870
4871 typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT32
4872 {
4873     VkStructureType sType;
4874     PTR32 pNext;
4875     uint32_t maxDiscardRectangles;
4876 } VkPhysicalDeviceDiscardRectanglePropertiesEXT32;
4877
4878 typedef struct VkPhysicalDeviceSubgroupProperties32
4879 {
4880     VkStructureType sType;
4881     PTR32 pNext;
4882     uint32_t subgroupSize;
4883     VkShaderStageFlags supportedStages;
4884     VkSubgroupFeatureFlags supportedOperations;
4885     VkBool32 quadOperationsInAllStages;
4886 } VkPhysicalDeviceSubgroupProperties32;
4887
4888 typedef struct VkPhysicalDevicePointClippingProperties32
4889 {
4890     VkStructureType sType;
4891     PTR32 pNext;
4892     VkPointClippingBehavior pointClippingBehavior;
4893 } VkPhysicalDevicePointClippingProperties32;
4894 typedef VkPhysicalDevicePointClippingProperties32 VkPhysicalDevicePointClippingPropertiesKHR32;
4895
4896 typedef struct VkPhysicalDeviceProtectedMemoryProperties32
4897 {
4898     VkStructureType sType;
4899     PTR32 pNext;
4900     VkBool32 protectedNoFault;
4901 } VkPhysicalDeviceProtectedMemoryProperties32;
4902
4903 typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties32
4904 {
4905     VkStructureType sType;
4906     PTR32 pNext;
4907     VkBool32 filterMinmaxSingleComponentFormats;
4908     VkBool32 filterMinmaxImageComponentMapping;
4909 } VkPhysicalDeviceSamplerFilterMinmaxProperties32;
4910 typedef VkPhysicalDeviceSamplerFilterMinmaxProperties32 VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT32;
4911
4912 typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT32
4913 {
4914     VkStructureType sType;
4915     PTR32 pNext;
4916     VkSampleCountFlags sampleLocationSampleCounts;
4917     VkExtent2D maxSampleLocationGridSize;
4918     float sampleLocationCoordinateRange[2];
4919     uint32_t sampleLocationSubPixelBits;
4920     VkBool32 variableSampleLocations;
4921 } VkPhysicalDeviceSampleLocationsPropertiesEXT32;
4922
4923 typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32
4924 {
4925     VkStructureType sType;
4926     PTR32 pNext;
4927     uint32_t advancedBlendMaxColorAttachments;
4928     VkBool32 advancedBlendIndependentBlend;
4929     VkBool32 advancedBlendNonPremultipliedSrcColor;
4930     VkBool32 advancedBlendNonPremultipliedDstColor;
4931     VkBool32 advancedBlendCorrelatedOverlap;
4932     VkBool32 advancedBlendAllOperations;
4933 } VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32;
4934
4935 typedef struct VkPhysicalDeviceInlineUniformBlockProperties32
4936 {
4937     VkStructureType sType;
4938     PTR32 pNext;
4939     uint32_t maxInlineUniformBlockSize;
4940     uint32_t maxPerStageDescriptorInlineUniformBlocks;
4941     uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
4942     uint32_t maxDescriptorSetInlineUniformBlocks;
4943     uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
4944 } VkPhysicalDeviceInlineUniformBlockProperties32;
4945 typedef VkPhysicalDeviceInlineUniformBlockProperties32 VkPhysicalDeviceInlineUniformBlockPropertiesEXT32;
4946
4947 typedef struct VkPhysicalDeviceMaintenance3Properties32
4948 {
4949     VkStructureType sType;
4950     PTR32 pNext;
4951     uint32_t maxPerSetDescriptors;
4952     VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize;
4953 } VkPhysicalDeviceMaintenance3Properties32;
4954 typedef VkPhysicalDeviceMaintenance3Properties32 VkPhysicalDeviceMaintenance3PropertiesKHR32;
4955
4956 typedef struct VkPhysicalDeviceMaintenance4Properties32
4957 {
4958     VkStructureType sType;
4959     PTR32 pNext;
4960     VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize;
4961 } VkPhysicalDeviceMaintenance4Properties32;
4962 typedef VkPhysicalDeviceMaintenance4Properties32 VkPhysicalDeviceMaintenance4PropertiesKHR32;
4963
4964 typedef struct VkPhysicalDeviceFloatControlsProperties32
4965 {
4966     VkStructureType sType;
4967     PTR32 pNext;
4968     VkShaderFloatControlsIndependence denormBehaviorIndependence;
4969     VkShaderFloatControlsIndependence roundingModeIndependence;
4970     VkBool32 shaderSignedZeroInfNanPreserveFloat16;
4971     VkBool32 shaderSignedZeroInfNanPreserveFloat32;
4972     VkBool32 shaderSignedZeroInfNanPreserveFloat64;
4973     VkBool32 shaderDenormPreserveFloat16;
4974     VkBool32 shaderDenormPreserveFloat32;
4975     VkBool32 shaderDenormPreserveFloat64;
4976     VkBool32 shaderDenormFlushToZeroFloat16;
4977     VkBool32 shaderDenormFlushToZeroFloat32;
4978     VkBool32 shaderDenormFlushToZeroFloat64;
4979     VkBool32 shaderRoundingModeRTEFloat16;
4980     VkBool32 shaderRoundingModeRTEFloat32;
4981     VkBool32 shaderRoundingModeRTEFloat64;
4982     VkBool32 shaderRoundingModeRTZFloat16;
4983     VkBool32 shaderRoundingModeRTZFloat32;
4984     VkBool32 shaderRoundingModeRTZFloat64;
4985 } VkPhysicalDeviceFloatControlsProperties32;
4986 typedef VkPhysicalDeviceFloatControlsProperties32 VkPhysicalDeviceFloatControlsPropertiesKHR32;
4987
4988 typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT32
4989 {
4990     VkStructureType sType;
4991     PTR32 pNext;
4992     VkDeviceSize DECLSPEC_ALIGN(8) minImportedHostPointerAlignment;
4993 } VkPhysicalDeviceExternalMemoryHostPropertiesEXT32;
4994
4995 typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT32
4996 {
4997     VkStructureType sType;
4998     PTR32 pNext;
4999     float primitiveOverestimationSize;
5000     float maxExtraPrimitiveOverestimationSize;
5001     float extraPrimitiveOverestimationSizeGranularity;
5002     VkBool32 primitiveUnderestimation;
5003     VkBool32 conservativePointAndLineRasterization;
5004     VkBool32 degenerateTrianglesRasterized;
5005     VkBool32 degenerateLinesRasterized;
5006     VkBool32 fullyCoveredFragmentShaderInputVariable;
5007     VkBool32 conservativeRasterizationPostDepthCoverage;
5008 } VkPhysicalDeviceConservativeRasterizationPropertiesEXT32;
5009
5010 typedef struct VkPhysicalDeviceShaderCorePropertiesAMD32
5011 {
5012     VkStructureType sType;
5013     PTR32 pNext;
5014     uint32_t shaderEngineCount;
5015     uint32_t shaderArraysPerEngineCount;
5016     uint32_t computeUnitsPerShaderArray;
5017     uint32_t simdPerComputeUnit;
5018     uint32_t wavefrontsPerSimd;
5019     uint32_t wavefrontSize;
5020     uint32_t sgprsPerSimd;
5021     uint32_t minSgprAllocation;
5022     uint32_t maxSgprAllocation;
5023     uint32_t sgprAllocationGranularity;
5024     uint32_t vgprsPerSimd;
5025     uint32_t minVgprAllocation;
5026     uint32_t maxVgprAllocation;
5027     uint32_t vgprAllocationGranularity;
5028 } VkPhysicalDeviceShaderCorePropertiesAMD32;
5029
5030 typedef struct VkPhysicalDeviceShaderCoreProperties2AMD32
5031 {
5032     VkStructureType sType;
5033     PTR32 pNext;
5034     VkShaderCorePropertiesFlagsAMD shaderCoreFeatures;
5035     uint32_t activeComputeUnitCount;
5036 } VkPhysicalDeviceShaderCoreProperties2AMD32;
5037
5038 typedef struct VkPhysicalDeviceDescriptorIndexingProperties32
5039 {
5040     VkStructureType sType;
5041     PTR32 pNext;
5042     uint32_t maxUpdateAfterBindDescriptorsInAllPools;
5043     VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
5044     VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
5045     VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
5046     VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
5047     VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
5048     VkBool32 robustBufferAccessUpdateAfterBind;
5049     VkBool32 quadDivergentImplicitLod;
5050     uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
5051     uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
5052     uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
5053     uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
5054     uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
5055     uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
5056     uint32_t maxPerStageUpdateAfterBindResources;
5057     uint32_t maxDescriptorSetUpdateAfterBindSamplers;
5058     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
5059     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
5060     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
5061     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
5062     uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
5063     uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
5064     uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
5065 } VkPhysicalDeviceDescriptorIndexingProperties32;
5066 typedef VkPhysicalDeviceDescriptorIndexingProperties32 VkPhysicalDeviceDescriptorIndexingPropertiesEXT32;
5067
5068 typedef struct VkPhysicalDeviceTimelineSemaphoreProperties32
5069 {
5070     VkStructureType sType;
5071     PTR32 pNext;
5072     uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference;
5073 } VkPhysicalDeviceTimelineSemaphoreProperties32;
5074 typedef VkPhysicalDeviceTimelineSemaphoreProperties32 VkPhysicalDeviceTimelineSemaphorePropertiesKHR32;
5075
5076 typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32
5077 {
5078     VkStructureType sType;
5079     PTR32 pNext;
5080     uint32_t maxVertexAttribDivisor;
5081 } VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32;
5082
5083 typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT32
5084 {
5085     VkStructureType sType;
5086     PTR32 pNext;
5087     uint32_t pciDomain;
5088     uint32_t pciBus;
5089     uint32_t pciDevice;
5090     uint32_t pciFunction;
5091 } VkPhysicalDevicePCIBusInfoPropertiesEXT32;
5092
5093 typedef struct VkPhysicalDeviceDepthStencilResolveProperties32
5094 {
5095     VkStructureType sType;
5096     PTR32 pNext;
5097     VkResolveModeFlags supportedDepthResolveModes;
5098     VkResolveModeFlags supportedStencilResolveModes;
5099     VkBool32 independentResolveNone;
5100     VkBool32 independentResolve;
5101 } VkPhysicalDeviceDepthStencilResolveProperties32;
5102 typedef VkPhysicalDeviceDepthStencilResolveProperties32 VkPhysicalDeviceDepthStencilResolvePropertiesKHR32;
5103
5104 typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT32
5105 {
5106     VkStructureType sType;
5107     PTR32 pNext;
5108     uint32_t maxTransformFeedbackStreams;
5109     uint32_t maxTransformFeedbackBuffers;
5110     VkDeviceSize DECLSPEC_ALIGN(8) maxTransformFeedbackBufferSize;
5111     uint32_t maxTransformFeedbackStreamDataSize;
5112     uint32_t maxTransformFeedbackBufferDataSize;
5113     uint32_t maxTransformFeedbackBufferDataStride;
5114     VkBool32 transformFeedbackQueries;
5115     VkBool32 transformFeedbackStreamsLinesTriangles;
5116     VkBool32 transformFeedbackRasterizationStreamSelect;
5117     VkBool32 transformFeedbackDraw;
5118 } VkPhysicalDeviceTransformFeedbackPropertiesEXT32;
5119
5120 typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32
5121 {
5122     VkStructureType sType;
5123     PTR32 pNext;
5124     VkQueueFlags supportedQueues;
5125 } VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32;
5126
5127 typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesNV32
5128 {
5129     VkStructureType sType;
5130     PTR32 pNext;
5131     VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethods;
5132     uint64_t DECLSPEC_ALIGN(8) maxDecompressionIndirectCount;
5133 } VkPhysicalDeviceMemoryDecompressionPropertiesNV32;
5134
5135 typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV32
5136 {
5137     VkStructureType sType;
5138     PTR32 pNext;
5139     VkExtent2D shadingRateTexelSize;
5140     uint32_t shadingRatePaletteSize;
5141     uint32_t shadingRateMaxCoarseSamples;
5142 } VkPhysicalDeviceShadingRateImagePropertiesNV32;
5143
5144 typedef struct VkPhysicalDeviceMeshShaderPropertiesNV32
5145 {
5146     VkStructureType sType;
5147     PTR32 pNext;
5148     uint32_t maxDrawMeshTasksCount;
5149     uint32_t maxTaskWorkGroupInvocations;
5150     uint32_t maxTaskWorkGroupSize[3];
5151     uint32_t maxTaskTotalMemorySize;
5152     uint32_t maxTaskOutputCount;
5153     uint32_t maxMeshWorkGroupInvocations;
5154     uint32_t maxMeshWorkGroupSize[3];
5155     uint32_t maxMeshTotalMemorySize;
5156     uint32_t maxMeshOutputVertices;
5157     uint32_t maxMeshOutputPrimitives;
5158     uint32_t maxMeshMultiviewViewCount;
5159     uint32_t meshOutputPerVertexGranularity;
5160     uint32_t meshOutputPerPrimitiveGranularity;
5161 } VkPhysicalDeviceMeshShaderPropertiesNV32;
5162
5163 typedef struct VkPhysicalDeviceMeshShaderPropertiesEXT32
5164 {
5165     VkStructureType sType;
5166     PTR32 pNext;
5167     uint32_t maxTaskWorkGroupTotalCount;
5168     uint32_t maxTaskWorkGroupCount[3];
5169     uint32_t maxTaskWorkGroupInvocations;
5170     uint32_t maxTaskWorkGroupSize[3];
5171     uint32_t maxTaskPayloadSize;
5172     uint32_t maxTaskSharedMemorySize;
5173     uint32_t maxTaskPayloadAndSharedMemorySize;
5174     uint32_t maxMeshWorkGroupTotalCount;
5175     uint32_t maxMeshWorkGroupCount[3];
5176     uint32_t maxMeshWorkGroupInvocations;
5177     uint32_t maxMeshWorkGroupSize[3];
5178     uint32_t maxMeshSharedMemorySize;
5179     uint32_t maxMeshPayloadAndSharedMemorySize;
5180     uint32_t maxMeshOutputMemorySize;
5181     uint32_t maxMeshPayloadAndOutputMemorySize;
5182     uint32_t maxMeshOutputComponents;
5183     uint32_t maxMeshOutputVertices;
5184     uint32_t maxMeshOutputPrimitives;
5185     uint32_t maxMeshOutputLayers;
5186     uint32_t maxMeshMultiviewViewCount;
5187     uint32_t meshOutputPerVertexGranularity;
5188     uint32_t meshOutputPerPrimitiveGranularity;
5189     uint32_t maxPreferredTaskWorkGroupInvocations;
5190     uint32_t maxPreferredMeshWorkGroupInvocations;
5191     VkBool32 prefersLocalInvocationVertexOutput;
5192     VkBool32 prefersLocalInvocationPrimitiveOutput;
5193     VkBool32 prefersCompactVertexOutput;
5194     VkBool32 prefersCompactPrimitiveOutput;
5195 } VkPhysicalDeviceMeshShaderPropertiesEXT32;
5196
5197 typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR32
5198 {
5199     VkStructureType sType;
5200     PTR32 pNext;
5201     uint64_t DECLSPEC_ALIGN(8) maxGeometryCount;
5202     uint64_t DECLSPEC_ALIGN(8) maxInstanceCount;
5203     uint64_t DECLSPEC_ALIGN(8) maxPrimitiveCount;
5204     uint32_t maxPerStageDescriptorAccelerationStructures;
5205     uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
5206     uint32_t maxDescriptorSetAccelerationStructures;
5207     uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures;
5208     uint32_t minAccelerationStructureScratchOffsetAlignment;
5209 } VkPhysicalDeviceAccelerationStructurePropertiesKHR32;
5210
5211 typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR32
5212 {
5213     VkStructureType sType;
5214     PTR32 pNext;
5215     uint32_t shaderGroupHandleSize;
5216     uint32_t maxRayRecursionDepth;
5217     uint32_t maxShaderGroupStride;
5218     uint32_t shaderGroupBaseAlignment;
5219     uint32_t shaderGroupHandleCaptureReplaySize;
5220     uint32_t maxRayDispatchInvocationCount;
5221     uint32_t shaderGroupHandleAlignment;
5222     uint32_t maxRayHitAttributeSize;
5223 } VkPhysicalDeviceRayTracingPipelinePropertiesKHR32;
5224
5225 typedef struct VkPhysicalDeviceRayTracingPropertiesNV32
5226 {
5227     VkStructureType sType;
5228     PTR32 pNext;
5229     uint32_t shaderGroupHandleSize;
5230     uint32_t maxRecursionDepth;
5231     uint32_t maxShaderGroupStride;
5232     uint32_t shaderGroupBaseAlignment;
5233     uint64_t DECLSPEC_ALIGN(8) maxGeometryCount;
5234     uint64_t DECLSPEC_ALIGN(8) maxInstanceCount;
5235     uint64_t DECLSPEC_ALIGN(8) maxTriangleCount;
5236     uint32_t maxDescriptorSetAccelerationStructures;
5237 } VkPhysicalDeviceRayTracingPropertiesNV32;
5238
5239 typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT32
5240 {
5241     VkStructureType sType;
5242     PTR32 pNext;
5243     VkExtent2D minFragmentDensityTexelSize;
5244     VkExtent2D maxFragmentDensityTexelSize;
5245     VkBool32 fragmentDensityInvocations;
5246 } VkPhysicalDeviceFragmentDensityMapPropertiesEXT32;
5247
5248 typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32
5249 {
5250     VkStructureType sType;
5251     PTR32 pNext;
5252     VkBool32 subsampledLoads;
5253     VkBool32 subsampledCoarseReconstructionEarlyAccess;
5254     uint32_t maxSubsampledArrayLayers;
5255     uint32_t maxDescriptorSetSubsampledSamplers;
5256 } VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32;
5257
5258 typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32
5259 {
5260     VkStructureType sType;
5261     PTR32 pNext;
5262     VkExtent2D fragmentDensityOffsetGranularity;
5263 } VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32;
5264
5265 typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV32
5266 {
5267     VkStructureType sType;
5268     PTR32 pNext;
5269     VkShaderStageFlags cooperativeMatrixSupportedStages;
5270 } VkPhysicalDeviceCooperativeMatrixPropertiesNV32;
5271
5272 typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR32
5273 {
5274     VkStructureType sType;
5275     PTR32 pNext;
5276     VkBool32 allowCommandBufferQueryCopies;
5277 } VkPhysicalDevicePerformanceQueryPropertiesKHR32;
5278
5279 typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32
5280 {
5281     VkStructureType sType;
5282     PTR32 pNext;
5283     uint32_t shaderSMCount;
5284     uint32_t shaderWarpsPerSM;
5285 } VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32;
5286
5287 typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties32
5288 {
5289     VkStructureType sType;
5290     PTR32 pNext;
5291     VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes;
5292     VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
5293     VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes;
5294     VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
5295 } VkPhysicalDeviceTexelBufferAlignmentProperties32;
5296 typedef VkPhysicalDeviceTexelBufferAlignmentProperties32 VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT32;
5297
5298 typedef struct VkPhysicalDeviceSubgroupSizeControlProperties32
5299 {
5300     VkStructureType sType;
5301     PTR32 pNext;
5302     uint32_t minSubgroupSize;
5303     uint32_t maxSubgroupSize;
5304     uint32_t maxComputeWorkgroupSubgroups;
5305     VkShaderStageFlags requiredSubgroupSizeStages;
5306 } VkPhysicalDeviceSubgroupSizeControlProperties32;
5307 typedef VkPhysicalDeviceSubgroupSizeControlProperties32 VkPhysicalDeviceSubgroupSizeControlPropertiesEXT32;
5308
5309 typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32
5310 {
5311     VkStructureType sType;
5312     PTR32 pNext;
5313     uint32_t maxSubpassShadingWorkgroupSizeAspectRatio;
5314 } VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32;
5315
5316 typedef struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32
5317 {
5318     VkStructureType sType;
5319     PTR32 pNext;
5320     uint32_t maxWorkGroupCount[3];
5321     uint32_t maxWorkGroupSize[3];
5322     uint32_t maxOutputClusterCount;
5323     VkDeviceSize DECLSPEC_ALIGN(8) indirectBufferOffsetAlignment;
5324 } VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32;
5325
5326 typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT32
5327 {
5328     VkStructureType sType;
5329     PTR32 pNext;
5330     uint32_t lineSubPixelPrecisionBits;
5331 } VkPhysicalDeviceLineRasterizationPropertiesEXT32;
5332
5333 typedef struct VkPhysicalDeviceVulkan11Properties32
5334 {
5335     VkStructureType sType;
5336     PTR32 pNext;
5337     uint8_t deviceUUID[VK_UUID_SIZE];
5338     uint8_t driverUUID[VK_UUID_SIZE];
5339     uint8_t deviceLUID[VK_LUID_SIZE];
5340     uint32_t deviceNodeMask;
5341     VkBool32 deviceLUIDValid;
5342     uint32_t subgroupSize;
5343     VkShaderStageFlags subgroupSupportedStages;
5344     VkSubgroupFeatureFlags subgroupSupportedOperations;
5345     VkBool32 subgroupQuadOperationsInAllStages;
5346     VkPointClippingBehavior pointClippingBehavior;
5347     uint32_t maxMultiviewViewCount;
5348     uint32_t maxMultiviewInstanceIndex;
5349     VkBool32 protectedNoFault;
5350     uint32_t maxPerSetDescriptors;
5351     VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize;
5352 } VkPhysicalDeviceVulkan11Properties32;
5353
5354 typedef struct VkPhysicalDeviceVulkan12Properties32
5355 {
5356     VkStructureType sType;
5357     PTR32 pNext;
5358     VkDriverId driverID;
5359     char driverName[VK_MAX_DRIVER_NAME_SIZE];
5360     char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
5361     VkConformanceVersion conformanceVersion;
5362     VkShaderFloatControlsIndependence denormBehaviorIndependence;
5363     VkShaderFloatControlsIndependence roundingModeIndependence;
5364     VkBool32 shaderSignedZeroInfNanPreserveFloat16;
5365     VkBool32 shaderSignedZeroInfNanPreserveFloat32;
5366     VkBool32 shaderSignedZeroInfNanPreserveFloat64;
5367     VkBool32 shaderDenormPreserveFloat16;
5368     VkBool32 shaderDenormPreserveFloat32;
5369     VkBool32 shaderDenormPreserveFloat64;
5370     VkBool32 shaderDenormFlushToZeroFloat16;
5371     VkBool32 shaderDenormFlushToZeroFloat32;
5372     VkBool32 shaderDenormFlushToZeroFloat64;
5373     VkBool32 shaderRoundingModeRTEFloat16;
5374     VkBool32 shaderRoundingModeRTEFloat32;
5375     VkBool32 shaderRoundingModeRTEFloat64;
5376     VkBool32 shaderRoundingModeRTZFloat16;
5377     VkBool32 shaderRoundingModeRTZFloat32;
5378     VkBool32 shaderRoundingModeRTZFloat64;
5379     uint32_t maxUpdateAfterBindDescriptorsInAllPools;
5380     VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
5381     VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
5382     VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
5383     VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
5384     VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
5385     VkBool32 robustBufferAccessUpdateAfterBind;
5386     VkBool32 quadDivergentImplicitLod;
5387     uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
5388     uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
5389     uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
5390     uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
5391     uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
5392     uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
5393     uint32_t maxPerStageUpdateAfterBindResources;
5394     uint32_t maxDescriptorSetUpdateAfterBindSamplers;
5395     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
5396     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
5397     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
5398     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
5399     uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
5400     uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
5401     uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
5402     VkResolveModeFlags supportedDepthResolveModes;
5403     VkResolveModeFlags supportedStencilResolveModes;
5404     VkBool32 independentResolveNone;
5405     VkBool32 independentResolve;
5406     VkBool32 filterMinmaxSingleComponentFormats;
5407     VkBool32 filterMinmaxImageComponentMapping;
5408     uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference;
5409     VkSampleCountFlags framebufferIntegerColorSampleCounts;
5410 } VkPhysicalDeviceVulkan12Properties32;
5411
5412 typedef struct VkPhysicalDeviceVulkan13Properties32
5413 {
5414     VkStructureType sType;
5415     PTR32 pNext;
5416     uint32_t minSubgroupSize;
5417     uint32_t maxSubgroupSize;
5418     uint32_t maxComputeWorkgroupSubgroups;
5419     VkShaderStageFlags requiredSubgroupSizeStages;
5420     uint32_t maxInlineUniformBlockSize;
5421     uint32_t maxPerStageDescriptorInlineUniformBlocks;
5422     uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
5423     uint32_t maxDescriptorSetInlineUniformBlocks;
5424     uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
5425     uint32_t maxInlineUniformTotalSize;
5426     VkBool32 integerDotProduct8BitUnsignedAccelerated;
5427     VkBool32 integerDotProduct8BitSignedAccelerated;
5428     VkBool32 integerDotProduct8BitMixedSignednessAccelerated;
5429     VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;
5430     VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;
5431     VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;
5432     VkBool32 integerDotProduct16BitUnsignedAccelerated;
5433     VkBool32 integerDotProduct16BitSignedAccelerated;
5434     VkBool32 integerDotProduct16BitMixedSignednessAccelerated;
5435     VkBool32 integerDotProduct32BitUnsignedAccelerated;
5436     VkBool32 integerDotProduct32BitSignedAccelerated;
5437     VkBool32 integerDotProduct32BitMixedSignednessAccelerated;
5438     VkBool32 integerDotProduct64BitUnsignedAccelerated;
5439     VkBool32 integerDotProduct64BitSignedAccelerated;
5440     VkBool32 integerDotProduct64BitMixedSignednessAccelerated;
5441     VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
5442     VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;
5443     VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
5444     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
5445     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
5446     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
5447     VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
5448     VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;
5449     VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
5450     VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
5451     VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;
5452     VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
5453     VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
5454     VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;
5455     VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
5456     VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes;
5457     VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
5458     VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes;
5459     VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
5460     VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize;
5461 } VkPhysicalDeviceVulkan13Properties32;
5462
5463 typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT32
5464 {
5465     VkStructureType sType;
5466     PTR32 pNext;
5467     uint32_t maxCustomBorderColorSamplers;
5468 } VkPhysicalDeviceCustomBorderColorPropertiesEXT32;
5469
5470 typedef struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32
5471 {
5472     VkStructureType sType;
5473     PTR32 pNext;
5474     VkBool32 dynamicPrimitiveTopologyUnrestricted;
5475 } VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32;
5476
5477 typedef struct VkPhysicalDeviceRobustness2PropertiesEXT32
5478 {
5479     VkStructureType sType;
5480     PTR32 pNext;
5481     VkDeviceSize DECLSPEC_ALIGN(8) robustStorageBufferAccessSizeAlignment;
5482     VkDeviceSize DECLSPEC_ALIGN(8) robustUniformBufferAccessSizeAlignment;
5483 } VkPhysicalDeviceRobustness2PropertiesEXT32;
5484
5485 typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR32
5486 {
5487     VkStructureType sType;
5488     PTR32 pNext;
5489     VkExtent2D minFragmentShadingRateAttachmentTexelSize;
5490     VkExtent2D maxFragmentShadingRateAttachmentTexelSize;
5491     uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
5492     VkBool32 primitiveFragmentShadingRateWithMultipleViewports;
5493     VkBool32 layeredShadingRateAttachments;
5494     VkBool32 fragmentShadingRateNonTrivialCombinerOps;
5495     VkExtent2D maxFragmentSize;
5496     uint32_t maxFragmentSizeAspectRatio;
5497     uint32_t maxFragmentShadingRateCoverageSamples;
5498     VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples;
5499     VkBool32 fragmentShadingRateWithShaderDepthStencilWrites;
5500     VkBool32 fragmentShadingRateWithSampleMask;
5501     VkBool32 fragmentShadingRateWithShaderSampleMask;
5502     VkBool32 fragmentShadingRateWithConservativeRasterization;
5503     VkBool32 fragmentShadingRateWithFragmentShaderInterlock;
5504     VkBool32 fragmentShadingRateWithCustomSampleLocations;
5505     VkBool32 fragmentShadingRateStrictMultiplyCombiner;
5506 } VkPhysicalDeviceFragmentShadingRatePropertiesKHR32;
5507
5508 typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32
5509 {
5510     VkStructureType sType;
5511     PTR32 pNext;
5512     VkSampleCountFlagBits maxFragmentShadingRateInvocationCount;
5513 } VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32;
5514
5515 typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT32
5516 {
5517     VkStructureType sType;
5518     PTR32 pNext;
5519     VkBool32 provokingVertexModePerPipeline;
5520     VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex;
5521 } VkPhysicalDeviceProvokingVertexPropertiesEXT32;
5522
5523 typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT32
5524 {
5525     VkStructureType sType;
5526     PTR32 pNext;
5527     VkBool32 combinedImageSamplerDescriptorSingleArray;
5528     VkBool32 bufferlessPushDescriptors;
5529     VkBool32 allowSamplerImageViewPostSubmitCreation;
5530     VkDeviceSize DECLSPEC_ALIGN(8) descriptorBufferOffsetAlignment;
5531     uint32_t maxDescriptorBufferBindings;
5532     uint32_t maxResourceDescriptorBufferBindings;
5533     uint32_t maxSamplerDescriptorBufferBindings;
5534     uint32_t maxEmbeddedImmutableSamplerBindings;
5535     uint32_t maxEmbeddedImmutableSamplers;
5536     PTR32 bufferCaptureReplayDescriptorDataSize;
5537     PTR32 imageCaptureReplayDescriptorDataSize;
5538     PTR32 imageViewCaptureReplayDescriptorDataSize;
5539     PTR32 samplerCaptureReplayDescriptorDataSize;
5540     PTR32 accelerationStructureCaptureReplayDescriptorDataSize;
5541     PTR32 samplerDescriptorSize;
5542     PTR32 combinedImageSamplerDescriptorSize;
5543     PTR32 sampledImageDescriptorSize;
5544     PTR32 storageImageDescriptorSize;
5545     PTR32 uniformTexelBufferDescriptorSize;
5546     PTR32 robustUniformTexelBufferDescriptorSize;
5547     PTR32 storageTexelBufferDescriptorSize;
5548     PTR32 robustStorageTexelBufferDescriptorSize;
5549     PTR32 uniformBufferDescriptorSize;
5550     PTR32 robustUniformBufferDescriptorSize;
5551     PTR32 storageBufferDescriptorSize;
5552     PTR32 robustStorageBufferDescriptorSize;
5553     PTR32 inputAttachmentDescriptorSize;
5554     PTR32 accelerationStructureDescriptorSize;
5555     VkDeviceSize DECLSPEC_ALIGN(8) maxSamplerDescriptorBufferRange;
5556     VkDeviceSize DECLSPEC_ALIGN(8) maxResourceDescriptorBufferRange;
5557     VkDeviceSize DECLSPEC_ALIGN(8) samplerDescriptorBufferAddressSpaceSize;
5558     VkDeviceSize DECLSPEC_ALIGN(8) resourceDescriptorBufferAddressSpaceSize;
5559     VkDeviceSize DECLSPEC_ALIGN(8) descriptorBufferAddressSpaceSize;
5560 } VkPhysicalDeviceDescriptorBufferPropertiesEXT32;
5561
5562 typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32
5563 {
5564     VkStructureType sType;
5565     PTR32 pNext;
5566     PTR32 combinedImageSamplerDensityMapDescriptorSize;
5567 } VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32;
5568
5569 typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties32
5570 {
5571     VkStructureType sType;
5572     PTR32 pNext;
5573     VkBool32 integerDotProduct8BitUnsignedAccelerated;
5574     VkBool32 integerDotProduct8BitSignedAccelerated;
5575     VkBool32 integerDotProduct8BitMixedSignednessAccelerated;
5576     VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;
5577     VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;
5578     VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;
5579     VkBool32 integerDotProduct16BitUnsignedAccelerated;
5580     VkBool32 integerDotProduct16BitSignedAccelerated;
5581     VkBool32 integerDotProduct16BitMixedSignednessAccelerated;
5582     VkBool32 integerDotProduct32BitUnsignedAccelerated;
5583     VkBool32 integerDotProduct32BitSignedAccelerated;
5584     VkBool32 integerDotProduct32BitMixedSignednessAccelerated;
5585     VkBool32 integerDotProduct64BitUnsignedAccelerated;
5586     VkBool32 integerDotProduct64BitSignedAccelerated;
5587     VkBool32 integerDotProduct64BitMixedSignednessAccelerated;
5588     VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
5589     VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;
5590     VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
5591     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
5592     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
5593     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
5594     VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
5595     VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;
5596     VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
5597     VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
5598     VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;
5599     VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
5600     VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
5601     VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;
5602     VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
5603 } VkPhysicalDeviceShaderIntegerDotProductProperties32;
5604 typedef VkPhysicalDeviceShaderIntegerDotProductProperties32 VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR32;
5605
5606 typedef struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32
5607 {
5608     VkStructureType sType;
5609     PTR32 pNext;
5610     VkBool32 triStripVertexOrderIndependentOfProvokingVertex;
5611 } VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32;
5612
5613 typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32
5614 {
5615     VkStructureType sType;
5616     PTR32 pNext;
5617     VkBool32 graphicsPipelineLibraryFastLinking;
5618     VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration;
5619 } VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32;
5620
5621 typedef struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32
5622 {
5623     VkStructureType sType;
5624     PTR32 pNext;
5625     uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE];
5626 } VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32;
5627
5628 typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT32
5629 {
5630     VkStructureType sType;
5631     PTR32 pNext;
5632     uint32_t maxOpacity2StateSubdivisionLevel;
5633     uint32_t maxOpacity4StateSubdivisionLevel;
5634 } VkPhysicalDeviceOpacityMicromapPropertiesEXT32;
5635
5636 typedef struct VkPhysicalDevicePipelineRobustnessPropertiesEXT32
5637 {
5638     VkStructureType sType;
5639     PTR32 pNext;
5640     VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessStorageBuffers;
5641     VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessUniformBuffers;
5642     VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessVertexInputs;
5643     VkPipelineRobustnessImageBehaviorEXT defaultRobustnessImages;
5644 } VkPhysicalDevicePipelineRobustnessPropertiesEXT32;
5645
5646 typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM32
5647 {
5648     VkStructureType sType;
5649     PTR32 pNext;
5650     uint32_t maxWeightFilterPhases;
5651     VkExtent2D maxWeightFilterDimension;
5652     VkExtent2D maxBlockMatchRegion;
5653     VkExtent2D maxBoxFilterBlockSize;
5654 } VkPhysicalDeviceImageProcessingPropertiesQCOM32;
5655
5656 typedef struct VkPhysicalDeviceOpticalFlowPropertiesNV32
5657 {
5658     VkStructureType sType;
5659     PTR32 pNext;
5660     VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes;
5661     VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes;
5662     VkBool32 hintSupported;
5663     VkBool32 costSupported;
5664     VkBool32 bidirectionalFlowSupported;
5665     VkBool32 globalFlowSupported;
5666     uint32_t minWidth;
5667     uint32_t minHeight;
5668     uint32_t maxWidth;
5669     uint32_t maxHeight;
5670     uint32_t maxNumRegionsOfInterest;
5671 } VkPhysicalDeviceOpticalFlowPropertiesNV32;
5672
5673 typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32
5674 {
5675     VkStructureType sType;
5676     PTR32 pNext;
5677     uint64_t DECLSPEC_ALIGN(8) shaderCoreMask;
5678     uint32_t shaderCoreCount;
5679     uint32_t shaderWarpsPerCore;
5680 } VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32;
5681
5682 typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32
5683 {
5684     VkStructureType sType;
5685     PTR32 pNext;
5686     VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint;
5687 } VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32;
5688
5689 typedef struct VkPhysicalDeviceShaderCorePropertiesARM32
5690 {
5691     VkStructureType sType;
5692     PTR32 pNext;
5693     uint32_t pixelRate;
5694     uint32_t texelRate;
5695     uint32_t fmaRate;
5696 } VkPhysicalDeviceShaderCorePropertiesARM32;
5697
5698 typedef struct VkPhysicalDeviceShaderObjectPropertiesEXT32
5699 {
5700     VkStructureType sType;
5701     PTR32 pNext;
5702     uint8_t shaderBinaryUUID[VK_UUID_SIZE];
5703     uint32_t shaderBinaryVersion;
5704 } VkPhysicalDeviceShaderObjectPropertiesEXT32;
5705
5706 typedef struct VkPhysicalDeviceShaderTileImagePropertiesEXT32
5707 {
5708     VkStructureType sType;
5709     PTR32 pNext;
5710     VkBool32 shaderTileImageCoherentReadAccelerated;
5711     VkBool32 shaderTileImageReadSampleFromPixelRateInvocation;
5712     VkBool32 shaderTileImageReadFromHelperInvocation;
5713 } VkPhysicalDeviceShaderTileImagePropertiesEXT32;
5714
5715 typedef struct VkPhysicalDeviceProperties232
5716 {
5717     VkStructureType sType;
5718     PTR32 pNext;
5719     VkPhysicalDeviceProperties32 DECLSPEC_ALIGN(8) properties;
5720 } VkPhysicalDeviceProperties232;
5721 typedef VkPhysicalDeviceProperties232 VkPhysicalDeviceProperties2KHR32;
5722
5723 typedef struct VkQueueFamilyGlobalPriorityPropertiesKHR32
5724 {
5725     VkStructureType sType;
5726     PTR32 pNext;
5727     uint32_t priorityCount;
5728     VkQueueGlobalPriorityKHR priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_KHR];
5729 } VkQueueFamilyGlobalPriorityPropertiesKHR32;
5730 typedef VkQueueFamilyGlobalPriorityPropertiesKHR32 VkQueueFamilyGlobalPriorityPropertiesEXT32;
5731
5732 typedef struct VkQueueFamilyCheckpointPropertiesNV32
5733 {
5734     VkStructureType sType;
5735     PTR32 pNext;
5736     VkPipelineStageFlags checkpointExecutionStageMask;
5737 } VkQueueFamilyCheckpointPropertiesNV32;
5738
5739 typedef struct VkQueueFamilyCheckpointProperties2NV32
5740 {
5741     VkStructureType sType;
5742     PTR32 pNext;
5743     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) checkpointExecutionStageMask;
5744 } VkQueueFamilyCheckpointProperties2NV32;
5745
5746 typedef struct VkQueueFamilyProperties232
5747 {
5748     VkStructureType sType;
5749     PTR32 pNext;
5750     VkQueueFamilyProperties queueFamilyProperties;
5751 } VkQueueFamilyProperties232;
5752 typedef VkQueueFamilyProperties232 VkQueueFamilyProperties2KHR32;
5753
5754 typedef struct VkPhysicalDeviceSparseImageFormatInfo232
5755 {
5756     VkStructureType sType;
5757     PTR32 pNext;
5758     VkFormat format;
5759     VkImageType type;
5760     VkSampleCountFlagBits samples;
5761     VkImageUsageFlags usage;
5762     VkImageTiling tiling;
5763 } VkPhysicalDeviceSparseImageFormatInfo232;
5764 typedef VkPhysicalDeviceSparseImageFormatInfo232 VkPhysicalDeviceSparseImageFormatInfo2KHR32;
5765
5766 typedef struct VkSparseImageFormatProperties232
5767 {
5768     VkStructureType sType;
5769     PTR32 pNext;
5770     VkSparseImageFormatProperties properties;
5771 } VkSparseImageFormatProperties232;
5772 typedef VkSparseImageFormatProperties232 VkSparseImageFormatProperties2KHR32;
5773
5774 typedef struct VkFramebufferMixedSamplesCombinationNV32
5775 {
5776     VkStructureType sType;
5777     PTR32 pNext;
5778     VkCoverageReductionModeNV coverageReductionMode;
5779     VkSampleCountFlagBits rasterizationSamples;
5780     VkSampleCountFlags depthStencilSamples;
5781     VkSampleCountFlags colorSamples;
5782 } VkFramebufferMixedSamplesCombinationNV32;
5783
5784 typedef struct VkSurfacePresentModeEXT32
5785 {
5786     VkStructureType sType;
5787     PTR32 pNext;
5788     VkPresentModeKHR presentMode;
5789 } VkSurfacePresentModeEXT32;
5790
5791 typedef struct VkPhysicalDeviceSurfaceInfo2KHR32
5792 {
5793     VkStructureType sType;
5794     PTR32 pNext;
5795     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
5796 } VkPhysicalDeviceSurfaceInfo2KHR32;
5797
5798 typedef struct VkSurfaceCapabilitiesPresentBarrierNV32
5799 {
5800     VkStructureType sType;
5801     PTR32 pNext;
5802     VkBool32 presentBarrierSupported;
5803 } VkSurfaceCapabilitiesPresentBarrierNV32;
5804
5805 typedef struct VkSurfacePresentScalingCapabilitiesEXT32
5806 {
5807     VkStructureType sType;
5808     PTR32 pNext;
5809     VkPresentScalingFlagsEXT supportedPresentScaling;
5810     VkPresentGravityFlagsEXT supportedPresentGravityX;
5811     VkPresentGravityFlagsEXT supportedPresentGravityY;
5812     VkExtent2D minScaledImageExtent;
5813     VkExtent2D maxScaledImageExtent;
5814 } VkSurfacePresentScalingCapabilitiesEXT32;
5815
5816 typedef struct VkSurfacePresentModeCompatibilityEXT32
5817 {
5818     VkStructureType sType;
5819     PTR32 pNext;
5820     uint32_t presentModeCount;
5821     PTR32 pPresentModes;
5822 } VkSurfacePresentModeCompatibilityEXT32;
5823
5824 typedef struct VkSurfaceCapabilities2KHR32
5825 {
5826     VkStructureType sType;
5827     PTR32 pNext;
5828     VkSurfaceCapabilitiesKHR surfaceCapabilities;
5829 } VkSurfaceCapabilities2KHR32;
5830
5831 typedef struct VkSurfaceFormat2KHR32
5832 {
5833     VkStructureType sType;
5834     PTR32 pNext;
5835     VkSurfaceFormatKHR surfaceFormat;
5836 } VkSurfaceFormat2KHR32;
5837
5838 typedef struct VkPhysicalDeviceToolProperties32
5839 {
5840     VkStructureType sType;
5841     PTR32 pNext;
5842     char name[VK_MAX_EXTENSION_NAME_SIZE];
5843     char version[VK_MAX_EXTENSION_NAME_SIZE];
5844     VkToolPurposeFlags purposes;
5845     char description[VK_MAX_DESCRIPTION_SIZE];
5846     char layer[VK_MAX_EXTENSION_NAME_SIZE];
5847 } VkPhysicalDeviceToolProperties32;
5848 typedef VkPhysicalDeviceToolProperties32 VkPhysicalDeviceToolPropertiesEXT32;
5849
5850 typedef struct VkPipelineExecutableInfoKHR32
5851 {
5852     VkStructureType sType;
5853     PTR32 pNext;
5854     VkPipeline DECLSPEC_ALIGN(8) pipeline;
5855     uint32_t executableIndex;
5856 } VkPipelineExecutableInfoKHR32;
5857
5858 typedef struct VkPipelineExecutableInternalRepresentationKHR32
5859 {
5860     VkStructureType sType;
5861     PTR32 pNext;
5862     char name[VK_MAX_DESCRIPTION_SIZE];
5863     char description[VK_MAX_DESCRIPTION_SIZE];
5864     VkBool32 isText;
5865     PTR32 dataSize;
5866     PTR32 pData;
5867 } VkPipelineExecutableInternalRepresentationKHR32;
5868
5869 typedef struct VkPipelineInfoKHR32
5870 {
5871     VkStructureType sType;
5872     PTR32 pNext;
5873     VkPipeline DECLSPEC_ALIGN(8) pipeline;
5874 } VkPipelineInfoKHR32;
5875 typedef VkPipelineInfoKHR32 VkPipelineInfoEXT32;
5876
5877 typedef struct VkPipelineExecutablePropertiesKHR32
5878 {
5879     VkStructureType sType;
5880     PTR32 pNext;
5881     VkShaderStageFlags stages;
5882     char name[VK_MAX_DESCRIPTION_SIZE];
5883     char description[VK_MAX_DESCRIPTION_SIZE];
5884     uint32_t subgroupSize;
5885 } VkPipelineExecutablePropertiesKHR32;
5886
5887 typedef union VkPipelineExecutableStatisticValueKHR32
5888 {
5889     VkBool32 b32;
5890     int64_t i64;
5891     uint64_t DECLSPEC_ALIGN(8) u64;
5892     double f64;
5893 } VkPipelineExecutableStatisticValueKHR32;
5894
5895 typedef struct VkPipelineExecutableStatisticKHR32
5896 {
5897     VkStructureType sType;
5898     PTR32 pNext;
5899     char name[VK_MAX_DESCRIPTION_SIZE];
5900     char description[VK_MAX_DESCRIPTION_SIZE];
5901     VkPipelineExecutableStatisticFormatKHR format;
5902     VkPipelineExecutableStatisticValueKHR32 DECLSPEC_ALIGN(8) value;
5903 } VkPipelineExecutableStatisticKHR32;
5904
5905
5906 typedef struct VkCheckpointData2NV32
5907 {
5908     VkStructureType sType;
5909     PTR32 pNext;
5910     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
5911     PTR32 pCheckpointMarker;
5912 } VkCheckpointData2NV32;
5913
5914 typedef struct VkCheckpointDataNV32
5915 {
5916     VkStructureType sType;
5917     PTR32 pNext;
5918     VkPipelineStageFlagBits stage;
5919     PTR32 pCheckpointMarker;
5920 } VkCheckpointDataNV32;
5921
5922 typedef struct VkSamplerCaptureDescriptorDataInfoEXT32
5923 {
5924     VkStructureType sType;
5925     PTR32 pNext;
5926     VkSampler DECLSPEC_ALIGN(8) sampler;
5927 } VkSamplerCaptureDescriptorDataInfoEXT32;
5928
5929 typedef struct VkShaderModuleIdentifierEXT32
5930 {
5931     VkStructureType sType;
5932     PTR32 pNext;
5933     uint32_t identifierSize;
5934     uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT];
5935 } VkShaderModuleIdentifierEXT32;
5936
5937 typedef struct VkInitializePerformanceApiInfoINTEL32
5938 {
5939     VkStructureType sType;
5940     PTR32 pNext;
5941     PTR32 pUserData;
5942 } VkInitializePerformanceApiInfoINTEL32;
5943
5944 typedef struct VkMemoryMapInfoKHR32
5945 {
5946     VkStructureType sType;
5947     PTR32 pNext;
5948     VkMemoryMapFlags flags;
5949     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
5950     VkDeviceSize DECLSPEC_ALIGN(8) offset;
5951     VkDeviceSize DECLSPEC_ALIGN(8) size;
5952 } VkMemoryMapInfoKHR32;
5953
5954 typedef struct VkSparseMemoryBind32
5955 {
5956     VkDeviceSize DECLSPEC_ALIGN(8) resourceOffset;
5957     VkDeviceSize DECLSPEC_ALIGN(8) size;
5958     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
5959     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
5960     VkSparseMemoryBindFlags flags;
5961 } VkSparseMemoryBind32;
5962
5963 typedef struct VkSparseBufferMemoryBindInfo32
5964 {
5965     VkBuffer DECLSPEC_ALIGN(8) buffer;
5966     uint32_t bindCount;
5967     PTR32 pBinds;
5968 } VkSparseBufferMemoryBindInfo32;
5969
5970 typedef struct VkSparseImageOpaqueMemoryBindInfo32
5971 {
5972     VkImage DECLSPEC_ALIGN(8) image;
5973     uint32_t bindCount;
5974     PTR32 pBinds;
5975 } VkSparseImageOpaqueMemoryBindInfo32;
5976
5977 typedef struct VkSparseImageMemoryBind32
5978 {
5979     VkImageSubresource subresource;
5980     VkOffset3D offset;
5981     VkExtent3D extent;
5982     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
5983     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
5984     VkSparseMemoryBindFlags flags;
5985 } VkSparseImageMemoryBind32;
5986
5987 typedef struct VkSparseImageMemoryBindInfo32
5988 {
5989     VkImage DECLSPEC_ALIGN(8) image;
5990     uint32_t bindCount;
5991     PTR32 pBinds;
5992 } VkSparseImageMemoryBindInfo32;
5993
5994 typedef struct VkDeviceGroupBindSparseInfo32
5995 {
5996     VkStructureType sType;
5997     PTR32 pNext;
5998     uint32_t resourceDeviceIndex;
5999     uint32_t memoryDeviceIndex;
6000 } VkDeviceGroupBindSparseInfo32;
6001 typedef VkDeviceGroupBindSparseInfo32 VkDeviceGroupBindSparseInfoKHR32;
6002
6003 typedef struct VkTimelineSemaphoreSubmitInfo32
6004 {
6005     VkStructureType sType;
6006     PTR32 pNext;
6007     uint32_t waitSemaphoreValueCount;
6008     PTR32 pWaitSemaphoreValues;
6009     uint32_t signalSemaphoreValueCount;
6010     PTR32 pSignalSemaphoreValues;
6011 } VkTimelineSemaphoreSubmitInfo32;
6012 typedef VkTimelineSemaphoreSubmitInfo32 VkTimelineSemaphoreSubmitInfoKHR32;
6013
6014 typedef struct VkBindSparseInfo32
6015 {
6016     VkStructureType sType;
6017     PTR32 pNext;
6018     uint32_t waitSemaphoreCount;
6019     PTR32 pWaitSemaphores;
6020     uint32_t bufferBindCount;
6021     PTR32 pBufferBinds;
6022     uint32_t imageOpaqueBindCount;
6023     PTR32 pImageOpaqueBinds;
6024     uint32_t imageBindCount;
6025     PTR32 pImageBinds;
6026     uint32_t signalSemaphoreCount;
6027     PTR32 pSignalSemaphores;
6028 } VkBindSparseInfo32;
6029
6030 typedef struct VkPresentRegionKHR32
6031 {
6032     uint32_t rectangleCount;
6033     PTR32 pRectangles;
6034 } VkPresentRegionKHR32;
6035
6036 typedef struct VkPresentRegionsKHR32
6037 {
6038     VkStructureType sType;
6039     PTR32 pNext;
6040     uint32_t swapchainCount;
6041     PTR32 pRegions;
6042 } VkPresentRegionsKHR32;
6043
6044 typedef struct VkDeviceGroupPresentInfoKHR32
6045 {
6046     VkStructureType sType;
6047     PTR32 pNext;
6048     uint32_t swapchainCount;
6049     PTR32 pDeviceMasks;
6050     VkDeviceGroupPresentModeFlagBitsKHR mode;
6051 } VkDeviceGroupPresentInfoKHR32;
6052
6053 typedef struct VkPresentIdKHR32
6054 {
6055     VkStructureType sType;
6056     PTR32 pNext;
6057     uint32_t swapchainCount;
6058     PTR32 pPresentIds;
6059 } VkPresentIdKHR32;
6060
6061 typedef struct VkSwapchainPresentFenceInfoEXT32
6062 {
6063     VkStructureType sType;
6064     PTR32 pNext;
6065     uint32_t swapchainCount;
6066     PTR32 pFences;
6067 } VkSwapchainPresentFenceInfoEXT32;
6068
6069 typedef struct VkSwapchainPresentModeInfoEXT32
6070 {
6071     VkStructureType sType;
6072     PTR32 pNext;
6073     uint32_t swapchainCount;
6074     PTR32 pPresentModes;
6075 } VkSwapchainPresentModeInfoEXT32;
6076
6077 typedef struct VkPresentInfoKHR32
6078 {
6079     VkStructureType sType;
6080     PTR32 pNext;
6081     uint32_t waitSemaphoreCount;
6082     PTR32 pWaitSemaphores;
6083     uint32_t swapchainCount;
6084     PTR32 pSwapchains;
6085     PTR32 pImageIndices;
6086     PTR32 pResults;
6087 } VkPresentInfoKHR32;
6088
6089 typedef struct VkDeviceGroupSubmitInfo32
6090 {
6091     VkStructureType sType;
6092     PTR32 pNext;
6093     uint32_t waitSemaphoreCount;
6094     PTR32 pWaitSemaphoreDeviceIndices;
6095     uint32_t commandBufferCount;
6096     PTR32 pCommandBufferDeviceMasks;
6097     uint32_t signalSemaphoreCount;
6098     PTR32 pSignalSemaphoreDeviceIndices;
6099 } VkDeviceGroupSubmitInfo32;
6100 typedef VkDeviceGroupSubmitInfo32 VkDeviceGroupSubmitInfoKHR32;
6101
6102 typedef struct VkProtectedSubmitInfo32
6103 {
6104     VkStructureType sType;
6105     PTR32 pNext;
6106     VkBool32 protectedSubmit;
6107 } VkProtectedSubmitInfo32;
6108
6109 typedef struct VkPerformanceQuerySubmitInfoKHR32
6110 {
6111     VkStructureType sType;
6112     PTR32 pNext;
6113     uint32_t counterPassIndex;
6114 } VkPerformanceQuerySubmitInfoKHR32;
6115
6116 typedef struct VkSubmitInfo32
6117 {
6118     VkStructureType sType;
6119     PTR32 pNext;
6120     uint32_t waitSemaphoreCount;
6121     PTR32 pWaitSemaphores;
6122     PTR32 pWaitDstStageMask;
6123     uint32_t commandBufferCount;
6124     PTR32 pCommandBuffers;
6125     uint32_t signalSemaphoreCount;
6126     PTR32 pSignalSemaphores;
6127 } VkSubmitInfo32;
6128
6129 typedef struct VkSemaphoreSubmitInfo32
6130 {
6131     VkStructureType sType;
6132     PTR32 pNext;
6133     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
6134     uint64_t DECLSPEC_ALIGN(8) value;
6135     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
6136     uint32_t deviceIndex;
6137 } VkSemaphoreSubmitInfo32;
6138 typedef VkSemaphoreSubmitInfo32 VkSemaphoreSubmitInfoKHR32;
6139
6140 typedef struct VkCommandBufferSubmitInfo32
6141 {
6142     VkStructureType sType;
6143     PTR32 pNext;
6144     PTR32 commandBuffer;
6145     uint32_t deviceMask;
6146 } VkCommandBufferSubmitInfo32;
6147 typedef VkCommandBufferSubmitInfo32 VkCommandBufferSubmitInfoKHR32;
6148
6149 typedef struct VkSubmitInfo232
6150 {
6151     VkStructureType sType;
6152     PTR32 pNext;
6153     VkSubmitFlags flags;
6154     uint32_t waitSemaphoreInfoCount;
6155     PTR32 pWaitSemaphoreInfos;
6156     uint32_t commandBufferInfoCount;
6157     PTR32 pCommandBufferInfos;
6158     uint32_t signalSemaphoreInfoCount;
6159     PTR32 pSignalSemaphoreInfos;
6160 } VkSubmitInfo232;
6161 typedef VkSubmitInfo232 VkSubmitInfo2KHR32;
6162
6163 typedef struct VkReleaseSwapchainImagesInfoEXT32
6164 {
6165     VkStructureType sType;
6166     PTR32 pNext;
6167     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
6168     uint32_t imageIndexCount;
6169     PTR32 pImageIndices;
6170 } VkReleaseSwapchainImagesInfoEXT32;
6171
6172 typedef struct VkDebugUtilsObjectTagInfoEXT32
6173 {
6174     VkStructureType sType;
6175     PTR32 pNext;
6176     VkObjectType objectType;
6177     uint64_t DECLSPEC_ALIGN(8) objectHandle;
6178     uint64_t DECLSPEC_ALIGN(8) tagName;
6179     PTR32 tagSize;
6180     PTR32 pTag;
6181 } VkDebugUtilsObjectTagInfoEXT32;
6182
6183 typedef struct VkHdrMetadataEXT32
6184 {
6185     VkStructureType sType;
6186     PTR32 pNext;
6187     VkXYColorEXT displayPrimaryRed;
6188     VkXYColorEXT displayPrimaryGreen;
6189     VkXYColorEXT displayPrimaryBlue;
6190     VkXYColorEXT whitePoint;
6191     float maxLuminance;
6192     float minLuminance;
6193     float maxContentLightLevel;
6194     float maxFrameAverageLightLevel;
6195 } VkHdrMetadataEXT32;
6196
6197 typedef struct VkSemaphoreSignalInfo32
6198 {
6199     VkStructureType sType;
6200     PTR32 pNext;
6201     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
6202     uint64_t DECLSPEC_ALIGN(8) value;
6203 } VkSemaphoreSignalInfo32;
6204 typedef VkSemaphoreSignalInfo32 VkSemaphoreSignalInfoKHR32;
6205
6206 typedef struct VkDeviceAddressBindingCallbackDataEXT32
6207 {
6208     VkStructureType sType;
6209     PTR32 pNext;
6210     VkDeviceAddressBindingFlagsEXT flags;
6211     VkDeviceAddress DECLSPEC_ALIGN(8) baseAddress;
6212     VkDeviceSize DECLSPEC_ALIGN(8) size;
6213     VkDeviceAddressBindingTypeEXT bindingType;
6214 } VkDeviceAddressBindingCallbackDataEXT32;
6215
6216 typedef struct VkDebugUtilsMessengerCallbackDataEXT32
6217 {
6218     VkStructureType sType;
6219     PTR32 pNext;
6220     VkDebugUtilsMessengerCallbackDataFlagsEXT flags;
6221     PTR32 pMessageIdName;
6222     int32_t messageIdNumber;
6223     PTR32 pMessage;
6224     uint32_t queueLabelCount;
6225     PTR32 pQueueLabels;
6226     uint32_t cmdBufLabelCount;
6227     PTR32 pCmdBufLabels;
6228     uint32_t objectCount;
6229     PTR32 pObjects;
6230 } VkDebugUtilsMessengerCallbackDataEXT32;
6231
6232 typedef struct VkMemoryUnmapInfoKHR32
6233 {
6234     VkStructureType sType;
6235     PTR32 pNext;
6236     VkMemoryUnmapFlagsKHR flags;
6237     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
6238 } VkMemoryUnmapInfoKHR32;
6239
6240 typedef struct VkCopyDescriptorSet32
6241 {
6242     VkStructureType sType;
6243     PTR32 pNext;
6244     VkDescriptorSet DECLSPEC_ALIGN(8) srcSet;
6245     uint32_t srcBinding;
6246     uint32_t srcArrayElement;
6247     VkDescriptorSet DECLSPEC_ALIGN(8) dstSet;
6248     uint32_t dstBinding;
6249     uint32_t dstArrayElement;
6250     uint32_t descriptorCount;
6251 } VkCopyDescriptorSet32;
6252
6253 typedef struct VkSemaphoreWaitInfo32
6254 {
6255     VkStructureType sType;
6256     PTR32 pNext;
6257     VkSemaphoreWaitFlags flags;
6258     uint32_t semaphoreCount;
6259     PTR32 pSemaphores;
6260     PTR32 pValues;
6261 } VkSemaphoreWaitInfo32;
6262 typedef VkSemaphoreWaitInfo32 VkSemaphoreWaitInfoKHR32;
6263
6264 static uint64_t wine_vk_unwrap_handle(uint32_t type, uint64_t handle)
6265 {
6266     switch(type)
6267     {
6268     case VK_OBJECT_TYPE_COMMAND_BUFFER:
6269         return (uint64_t) (uintptr_t) wine_cmd_buffer_from_handle(((VkCommandBuffer) (uintptr_t) handle))->command_buffer;
6270     case VK_OBJECT_TYPE_COMMAND_POOL:
6271         return (uint64_t) wine_cmd_pool_from_handle(handle)->command_pool;
6272     case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT:
6273         return (uint64_t) wine_debug_report_callback_from_handle(handle)->debug_callback;
6274     case VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT:
6275         return (uint64_t) wine_debug_utils_messenger_from_handle(handle)->debug_messenger;
6276     case VK_OBJECT_TYPE_DEVICE:
6277         return (uint64_t) (uintptr_t) wine_device_from_handle(((VkDevice) (uintptr_t) handle))->device;
6278     case VK_OBJECT_TYPE_DEVICE_MEMORY:
6279         return (uint64_t) wine_device_memory_from_handle(handle)->memory;
6280     case VK_OBJECT_TYPE_INSTANCE:
6281         return (uint64_t) (uintptr_t) wine_instance_from_handle(((VkInstance) (uintptr_t) handle))->instance;
6282     case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
6283         return (uint64_t) (uintptr_t) wine_phys_dev_from_handle(((VkPhysicalDevice) (uintptr_t) handle))->phys_dev;
6284     case VK_OBJECT_TYPE_QUEUE:
6285         return (uint64_t) (uintptr_t) wine_queue_from_handle(((VkQueue) (uintptr_t) handle))->queue;
6286     case VK_OBJECT_TYPE_SURFACE_KHR:
6287         return (uint64_t) wine_surface_from_handle(handle)->surface;
6288     default:
6289        return handle;
6290     }
6291 }
6292
6293 static inline void convert_VkAcquireNextImageInfoKHR_win32_to_host(const VkAcquireNextImageInfoKHR32 *in, VkAcquireNextImageInfoKHR *out)
6294 {
6295     if (!in) return;
6296
6297     out->sType = in->sType;
6298     out->pNext = NULL;
6299     out->swapchain = in->swapchain;
6300     out->timeout = in->timeout;
6301     out->semaphore = in->semaphore;
6302     out->fence = in->fence;
6303     out->deviceMask = in->deviceMask;
6304     if (in->pNext)
6305         FIXME("Unexpected pNext\n");
6306 }
6307
6308 static inline void convert_VkPerformanceConfigurationAcquireInfoINTEL_win32_to_host(const VkPerformanceConfigurationAcquireInfoINTEL32 *in, VkPerformanceConfigurationAcquireInfoINTEL *out)
6309 {
6310     if (!in) return;
6311
6312     out->sType = in->sType;
6313     out->pNext = NULL;
6314     out->type = in->type;
6315     if (in->pNext)
6316         FIXME("Unexpected pNext\n");
6317 }
6318
6319 static inline void convert_VkAcquireProfilingLockInfoKHR_win32_to_host(const VkAcquireProfilingLockInfoKHR32 *in, VkAcquireProfilingLockInfoKHR *out)
6320 {
6321     if (!in) return;
6322
6323     out->sType = in->sType;
6324     out->pNext = NULL;
6325     out->flags = in->flags;
6326     out->timeout = in->timeout;
6327     if (in->pNext)
6328         FIXME("Unexpected pNext\n");
6329 }
6330
6331 static inline void convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host(const VkCommandBufferAllocateInfo32 *in, VkCommandBufferAllocateInfo *out)
6332 {
6333     if (!in) return;
6334
6335     out->sType = in->sType;
6336     out->pNext = NULL;
6337     out->commandPool = in->commandPool;
6338     out->level = in->level;
6339     out->commandBufferCount = in->commandBufferCount;
6340     if (in->pNext)
6341         FIXME("Unexpected pNext\n");
6342 }
6343
6344 static inline VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_unwrapped_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
6345 {
6346     VkCommandBuffer *out;
6347     unsigned int i;
6348
6349     if (!in || !count) return NULL;
6350
6351     out = conversion_context_alloc(ctx, count * sizeof(*out));
6352     for (i = 0; i < count; i++)
6353     {
6354         out[i] = UlongToPtr(in[i]);
6355     }
6356
6357     return out;
6358 }
6359
6360 static inline void convert_VkDescriptorSetAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetAllocateInfo32 *in, VkDescriptorSetAllocateInfo *out)
6361 {
6362     const VkBaseInStructure32 *in_header;
6363     VkBaseOutStructure *out_header = (void *)out;
6364
6365     if (!in) return;
6366
6367     out->sType = in->sType;
6368     out->pNext = NULL;
6369     out->descriptorPool = in->descriptorPool;
6370     out->descriptorSetCount = in->descriptorSetCount;
6371     out->pSetLayouts = (const VkDescriptorSetLayout *)UlongToPtr(in->pSetLayouts);
6372
6373     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6374     {
6375         switch (in_header->sType)
6376         {
6377         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
6378         {
6379             VkDescriptorSetVariableDescriptorCountAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6380             const VkDescriptorSetVariableDescriptorCountAllocateInfo32 *in_ext = (const VkDescriptorSetVariableDescriptorCountAllocateInfo32 *)in_header;
6381             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
6382             out_ext->pNext = NULL;
6383             out_ext->descriptorSetCount = in_ext->descriptorSetCount;
6384             out_ext->pDescriptorCounts = (const uint32_t *)UlongToPtr(in_ext->pDescriptorCounts);
6385             out_header->pNext = (void *)out_ext;
6386             out_header = (void *)out_ext;
6387             break;
6388         }
6389         default:
6390             FIXME("Unhandled sType %u.\n", in_header->sType);
6391             break;
6392         }
6393     }
6394 }
6395
6396 static inline void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkMemoryAllocateInfo32 *in, VkMemoryAllocateInfo *out)
6397 {
6398     const VkBaseInStructure32 *in_header;
6399     VkBaseOutStructure *out_header = (void *)out;
6400
6401     if (!in) return;
6402
6403     out->sType = in->sType;
6404     out->pNext = NULL;
6405     out->allocationSize = in->allocationSize;
6406     out->memoryTypeIndex = in->memoryTypeIndex;
6407
6408     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6409     {
6410         switch (in_header->sType)
6411         {
6412         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
6413         {
6414             VkDedicatedAllocationMemoryAllocateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6415             const VkDedicatedAllocationMemoryAllocateInfoNV32 *in_ext = (const VkDedicatedAllocationMemoryAllocateInfoNV32 *)in_header;
6416             out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV;
6417             out_ext->pNext = NULL;
6418             out_ext->image = in_ext->image;
6419             out_ext->buffer = in_ext->buffer;
6420             out_header->pNext = (void *)out_ext;
6421             out_header = (void *)out_ext;
6422             break;
6423         }
6424         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
6425         {
6426             VkExportMemoryAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6427             const VkExportMemoryAllocateInfo32 *in_ext = (const VkExportMemoryAllocateInfo32 *)in_header;
6428             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO;
6429             out_ext->pNext = NULL;
6430             out_ext->handleTypes = in_ext->handleTypes;
6431             out_header->pNext = (void *)out_ext;
6432             out_header = (void *)out_ext;
6433             break;
6434         }
6435         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
6436         {
6437             VkImportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6438             const VkImportMemoryWin32HandleInfoKHR32 *in_ext = (const VkImportMemoryWin32HandleInfoKHR32 *)in_header;
6439             out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
6440             out_ext->pNext = NULL;
6441             out_ext->handleType = in_ext->handleType;
6442             out_ext->handle = in_ext->handle;
6443             out_ext->name = in_ext->name;
6444             out_header->pNext = (void *)out_ext;
6445             out_header = (void *)out_ext;
6446             break;
6447         }
6448         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
6449         {
6450             VkExportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6451             const VkExportMemoryWin32HandleInfoKHR32 *in_ext = (const VkExportMemoryWin32HandleInfoKHR32 *)in_header;
6452             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
6453             out_ext->pNext = NULL;
6454             out_ext->pAttributes = (const SECURITY_ATTRIBUTES *)UlongToPtr(in_ext->pAttributes);
6455             out_ext->dwAccess = in_ext->dwAccess;
6456             out_ext->name = in_ext->name;
6457             out_header->pNext = (void *)out_ext;
6458             out_header = (void *)out_ext;
6459             break;
6460         }
6461         case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
6462         {
6463             VkMemoryAllocateFlagsInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6464             const VkMemoryAllocateFlagsInfo32 *in_ext = (const VkMemoryAllocateFlagsInfo32 *)in_header;
6465             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO;
6466             out_ext->pNext = NULL;
6467             out_ext->flags = in_ext->flags;
6468             out_ext->deviceMask = in_ext->deviceMask;
6469             out_header->pNext = (void *)out_ext;
6470             out_header = (void *)out_ext;
6471             break;
6472         }
6473         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
6474         {
6475             VkMemoryDedicatedAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6476             const VkMemoryDedicatedAllocateInfo32 *in_ext = (const VkMemoryDedicatedAllocateInfo32 *)in_header;
6477             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
6478             out_ext->pNext = NULL;
6479             out_ext->image = in_ext->image;
6480             out_ext->buffer = in_ext->buffer;
6481             out_header->pNext = (void *)out_ext;
6482             out_header = (void *)out_ext;
6483             break;
6484         }
6485         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
6486         {
6487             VkImportMemoryHostPointerInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6488             const VkImportMemoryHostPointerInfoEXT32 *in_ext = (const VkImportMemoryHostPointerInfoEXT32 *)in_header;
6489             out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT;
6490             out_ext->pNext = NULL;
6491             out_ext->handleType = in_ext->handleType;
6492             out_ext->pHostPointer = (void *)UlongToPtr(in_ext->pHostPointer);
6493             out_header->pNext = (void *)out_ext;
6494             out_header = (void *)out_ext;
6495             break;
6496         }
6497         case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
6498         {
6499             VkMemoryPriorityAllocateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6500             const VkMemoryPriorityAllocateInfoEXT32 *in_ext = (const VkMemoryPriorityAllocateInfoEXT32 *)in_header;
6501             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT;
6502             out_ext->pNext = NULL;
6503             out_ext->priority = in_ext->priority;
6504             out_header->pNext = (void *)out_ext;
6505             out_header = (void *)out_ext;
6506             break;
6507         }
6508         case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
6509         {
6510             VkMemoryOpaqueCaptureAddressAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6511             const VkMemoryOpaqueCaptureAddressAllocateInfo32 *in_ext = (const VkMemoryOpaqueCaptureAddressAllocateInfo32 *)in_header;
6512             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO;
6513             out_ext->pNext = NULL;
6514             out_ext->opaqueCaptureAddress = in_ext->opaqueCaptureAddress;
6515             out_header->pNext = (void *)out_ext;
6516             out_header = (void *)out_ext;
6517             break;
6518         }
6519         default:
6520             FIXME("Unhandled sType %u.\n", in_header->sType);
6521             break;
6522         }
6523     }
6524 }
6525
6526 static inline void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, VkCommandBufferInheritanceInfo *out)
6527 {
6528     const VkBaseInStructure32 *in_header;
6529     VkBaseOutStructure *out_header = (void *)out;
6530
6531     if (!in) return;
6532
6533     out->sType = in->sType;
6534     out->pNext = NULL;
6535     out->renderPass = in->renderPass;
6536     out->subpass = in->subpass;
6537     out->framebuffer = in->framebuffer;
6538     out->occlusionQueryEnable = in->occlusionQueryEnable;
6539     out->queryFlags = in->queryFlags;
6540     out->pipelineStatistics = in->pipelineStatistics;
6541
6542     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6543     {
6544         switch (in_header->sType)
6545         {
6546         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
6547         {
6548             VkCommandBufferInheritanceConditionalRenderingInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6549             const VkCommandBufferInheritanceConditionalRenderingInfoEXT32 *in_ext = (const VkCommandBufferInheritanceConditionalRenderingInfoEXT32 *)in_header;
6550             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT;
6551             out_ext->pNext = NULL;
6552             out_ext->conditionalRenderingEnable = in_ext->conditionalRenderingEnable;
6553             out_header->pNext = (void *)out_ext;
6554             out_header = (void *)out_ext;
6555             break;
6556         }
6557         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
6558         {
6559             VkCommandBufferInheritanceRenderPassTransformInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6560             const VkCommandBufferInheritanceRenderPassTransformInfoQCOM32 *in_ext = (const VkCommandBufferInheritanceRenderPassTransformInfoQCOM32 *)in_header;
6561             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM;
6562             out_ext->pNext = NULL;
6563             out_ext->transform = in_ext->transform;
6564             out_ext->renderArea = in_ext->renderArea;
6565             out_header->pNext = (void *)out_ext;
6566             out_header = (void *)out_ext;
6567             break;
6568         }
6569         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
6570         {
6571             VkCommandBufferInheritanceViewportScissorInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6572             const VkCommandBufferInheritanceViewportScissorInfoNV32 *in_ext = (const VkCommandBufferInheritanceViewportScissorInfoNV32 *)in_header;
6573             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV;
6574             out_ext->pNext = NULL;
6575             out_ext->viewportScissor2D = in_ext->viewportScissor2D;
6576             out_ext->viewportDepthCount = in_ext->viewportDepthCount;
6577             out_ext->pViewportDepths = (const VkViewport *)UlongToPtr(in_ext->pViewportDepths);
6578             out_header->pNext = (void *)out_ext;
6579             out_header = (void *)out_ext;
6580             break;
6581         }
6582         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
6583         {
6584             VkCommandBufferInheritanceRenderingInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6585             const VkCommandBufferInheritanceRenderingInfo32 *in_ext = (const VkCommandBufferInheritanceRenderingInfo32 *)in_header;
6586             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO;
6587             out_ext->pNext = NULL;
6588             out_ext->flags = in_ext->flags;
6589             out_ext->viewMask = in_ext->viewMask;
6590             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
6591             out_ext->pColorAttachmentFormats = (const VkFormat *)UlongToPtr(in_ext->pColorAttachmentFormats);
6592             out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
6593             out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
6594             out_ext->rasterizationSamples = in_ext->rasterizationSamples;
6595             out_header->pNext = (void *)out_ext;
6596             out_header = (void *)out_ext;
6597             break;
6598         }
6599         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
6600         {
6601             VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6602             const VkAttachmentSampleCountInfoAMD32 *in_ext = (const VkAttachmentSampleCountInfoAMD32 *)in_header;
6603             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
6604             out_ext->pNext = NULL;
6605             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
6606             out_ext->pColorAttachmentSamples = (const VkSampleCountFlagBits *)UlongToPtr(in_ext->pColorAttachmentSamples);
6607             out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
6608             out_header->pNext = (void *)out_ext;
6609             out_header = (void *)out_ext;
6610             break;
6611         }
6612         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
6613         {
6614             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6615             const VkMultiviewPerViewAttributesInfoNVX32 *in_ext = (const VkMultiviewPerViewAttributesInfoNVX32 *)in_header;
6616             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
6617             out_ext->pNext = NULL;
6618             out_ext->perViewAttributes = in_ext->perViewAttributes;
6619             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
6620             out_header->pNext = (void *)out_ext;
6621             out_header = (void *)out_ext;
6622             break;
6623         }
6624         default:
6625             FIXME("Unhandled sType %u.\n", in_header->sType);
6626             break;
6627         }
6628     }
6629 }
6630
6631 static inline const VkCommandBufferInheritanceInfo *convert_VkCommandBufferInheritanceInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, uint32_t count)
6632 {
6633     VkCommandBufferInheritanceInfo *out;
6634     unsigned int i;
6635
6636     if (!in || !count) return NULL;
6637
6638     out = conversion_context_alloc(ctx, count * sizeof(*out));
6639     for (i = 0; i < count; i++)
6640     {
6641         convert_VkCommandBufferInheritanceInfo_win32_to_host(ctx, &in[i], &out[i]);
6642     }
6643
6644     return out;
6645 }
6646
6647 static inline void convert_VkCommandBufferBeginInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferBeginInfo32 *in, VkCommandBufferBeginInfo *out)
6648 {
6649     const VkBaseInStructure32 *in_header;
6650     VkBaseOutStructure *out_header = (void *)out;
6651
6652     if (!in) return;
6653
6654     out->sType = in->sType;
6655     out->pNext = NULL;
6656     out->flags = in->flags;
6657     out->pInheritanceInfo = convert_VkCommandBufferInheritanceInfo_array_win32_to_host(ctx, (const VkCommandBufferInheritanceInfo32 *)UlongToPtr(in->pInheritanceInfo), 1);
6658
6659     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6660     {
6661         switch (in_header->sType)
6662         {
6663         case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
6664         {
6665             VkDeviceGroupCommandBufferBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6666             const VkDeviceGroupCommandBufferBeginInfo32 *in_ext = (const VkDeviceGroupCommandBufferBeginInfo32 *)in_header;
6667             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO;
6668             out_ext->pNext = NULL;
6669             out_ext->deviceMask = in_ext->deviceMask;
6670             out_header->pNext = (void *)out_ext;
6671             out_header = (void *)out_ext;
6672             break;
6673         }
6674         default:
6675             FIXME("Unhandled sType %u.\n", in_header->sType);
6676             break;
6677         }
6678     }
6679 }
6680
6681 #ifdef _WIN64
6682 static inline void convert_VkBindAccelerationStructureMemoryInfoNV_win64_to_host(const VkBindAccelerationStructureMemoryInfoNV *in, VkBindAccelerationStructureMemoryInfoNV *out)
6683 {
6684     if (!in) return;
6685
6686     out->sType = in->sType;
6687     out->pNext = in->pNext;
6688     out->accelerationStructure = in->accelerationStructure;
6689     out->memory = wine_device_memory_from_handle(in->memory)->memory;
6690     out->memoryOffset = in->memoryOffset;
6691     out->deviceIndexCount = in->deviceIndexCount;
6692     out->pDeviceIndices = in->pDeviceIndices;
6693 }
6694 #endif /* _WIN64 */
6695
6696 static inline void convert_VkBindAccelerationStructureMemoryInfoNV_win32_to_host(const VkBindAccelerationStructureMemoryInfoNV32 *in, VkBindAccelerationStructureMemoryInfoNV *out)
6697 {
6698     if (!in) return;
6699
6700     out->sType = in->sType;
6701     out->pNext = NULL;
6702     out->accelerationStructure = in->accelerationStructure;
6703     out->memory = wine_device_memory_from_handle(in->memory)->memory;
6704     out->memoryOffset = in->memoryOffset;
6705     out->deviceIndexCount = in->deviceIndexCount;
6706     out->pDeviceIndices = (const uint32_t *)UlongToPtr(in->pDeviceIndices);
6707     if (in->pNext)
6708         FIXME("Unexpected pNext\n");
6709 }
6710
6711 #ifdef _WIN64
6712 static inline const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccelerationStructureMemoryInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkBindAccelerationStructureMemoryInfoNV *in, uint32_t count)
6713 {
6714     VkBindAccelerationStructureMemoryInfoNV *out;
6715     unsigned int i;
6716
6717     if (!in || !count) return NULL;
6718
6719     out = conversion_context_alloc(ctx, count * sizeof(*out));
6720     for (i = 0; i < count; i++)
6721     {
6722         convert_VkBindAccelerationStructureMemoryInfoNV_win64_to_host(&in[i], &out[i]);
6723     }
6724
6725     return out;
6726 }
6727 #endif /* _WIN64 */
6728
6729 static inline const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccelerationStructureMemoryInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkBindAccelerationStructureMemoryInfoNV32 *in, uint32_t count)
6730 {
6731     VkBindAccelerationStructureMemoryInfoNV *out;
6732     unsigned int i;
6733
6734     if (!in || !count) return NULL;
6735
6736     out = conversion_context_alloc(ctx, count * sizeof(*out));
6737     for (i = 0; i < count; i++)
6738     {
6739         convert_VkBindAccelerationStructureMemoryInfoNV_win32_to_host(&in[i], &out[i]);
6740     }
6741
6742     return out;
6743 }
6744
6745 #ifdef _WIN64
6746 static inline void convert_VkBindBufferMemoryInfo_win64_to_host(const VkBindBufferMemoryInfo *in, VkBindBufferMemoryInfo *out)
6747 {
6748     if (!in) return;
6749
6750     out->sType = in->sType;
6751     out->pNext = in->pNext;
6752     out->buffer = in->buffer;
6753     out->memory = wine_device_memory_from_handle(in->memory)->memory;
6754     out->memoryOffset = in->memoryOffset;
6755 }
6756 #endif /* _WIN64 */
6757
6758 static inline void convert_VkBindBufferMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo32 *in, VkBindBufferMemoryInfo *out)
6759 {
6760     const VkBaseInStructure32 *in_header;
6761     VkBaseOutStructure *out_header = (void *)out;
6762
6763     if (!in) return;
6764
6765     out->sType = in->sType;
6766     out->pNext = NULL;
6767     out->buffer = in->buffer;
6768     out->memory = wine_device_memory_from_handle(in->memory)->memory;
6769     out->memoryOffset = in->memoryOffset;
6770
6771     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6772     {
6773         switch (in_header->sType)
6774         {
6775         case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
6776         {
6777             VkBindBufferMemoryDeviceGroupInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6778             const VkBindBufferMemoryDeviceGroupInfo32 *in_ext = (const VkBindBufferMemoryDeviceGroupInfo32 *)in_header;
6779             out_ext->sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO;
6780             out_ext->pNext = NULL;
6781             out_ext->deviceIndexCount = in_ext->deviceIndexCount;
6782             out_ext->pDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pDeviceIndices);
6783             out_header->pNext = (void *)out_ext;
6784             out_header = (void *)out_ext;
6785             break;
6786         }
6787         default:
6788             FIXME("Unhandled sType %u.\n", in_header->sType);
6789             break;
6790         }
6791     }
6792 }
6793
6794 #ifdef _WIN64
6795 static inline const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo *in, uint32_t count)
6796 {
6797     VkBindBufferMemoryInfo *out;
6798     unsigned int i;
6799
6800     if (!in || !count) return NULL;
6801
6802     out = conversion_context_alloc(ctx, count * sizeof(*out));
6803     for (i = 0; i < count; i++)
6804     {
6805         convert_VkBindBufferMemoryInfo_win64_to_host(&in[i], &out[i]);
6806     }
6807
6808     return out;
6809 }
6810 #endif /* _WIN64 */
6811
6812 static inline const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo32 *in, uint32_t count)
6813 {
6814     VkBindBufferMemoryInfo *out;
6815     unsigned int i;
6816
6817     if (!in || !count) return NULL;
6818
6819     out = conversion_context_alloc(ctx, count * sizeof(*out));
6820     for (i = 0; i < count; i++)
6821     {
6822         convert_VkBindBufferMemoryInfo_win32_to_host(ctx, &in[i], &out[i]);
6823     }
6824
6825     return out;
6826 }
6827
6828 #ifdef _WIN64
6829 static inline void convert_VkBindImageMemoryInfo_win64_to_host(const VkBindImageMemoryInfo *in, VkBindImageMemoryInfo *out)
6830 {
6831     if (!in) return;
6832
6833     out->sType = in->sType;
6834     out->pNext = in->pNext;
6835     out->image = in->image;
6836     out->memory = wine_device_memory_from_handle(in->memory)->memory;
6837     out->memoryOffset = in->memoryOffset;
6838 }
6839 #endif /* _WIN64 */
6840
6841 static inline void convert_VkBindImageMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, VkBindImageMemoryInfo *out)
6842 {
6843     const VkBaseInStructure32 *in_header;
6844     VkBaseOutStructure *out_header = (void *)out;
6845
6846     if (!in) return;
6847
6848     out->sType = in->sType;
6849     out->pNext = NULL;
6850     out->image = in->image;
6851     out->memory = wine_device_memory_from_handle(in->memory)->memory;
6852     out->memoryOffset = in->memoryOffset;
6853
6854     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6855     {
6856         switch (in_header->sType)
6857         {
6858         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
6859         {
6860             VkBindImageMemoryDeviceGroupInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6861             const VkBindImageMemoryDeviceGroupInfo32 *in_ext = (const VkBindImageMemoryDeviceGroupInfo32 *)in_header;
6862             out_ext->sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO;
6863             out_ext->pNext = NULL;
6864             out_ext->deviceIndexCount = in_ext->deviceIndexCount;
6865             out_ext->pDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pDeviceIndices);
6866             out_ext->splitInstanceBindRegionCount = in_ext->splitInstanceBindRegionCount;
6867             out_ext->pSplitInstanceBindRegions = (const VkRect2D *)UlongToPtr(in_ext->pSplitInstanceBindRegions);
6868             out_header->pNext = (void *)out_ext;
6869             out_header = (void *)out_ext;
6870             break;
6871         }
6872         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
6873         {
6874             VkBindImageMemorySwapchainInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6875             const VkBindImageMemorySwapchainInfoKHR32 *in_ext = (const VkBindImageMemorySwapchainInfoKHR32 *)in_header;
6876             out_ext->sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR;
6877             out_ext->pNext = NULL;
6878             out_ext->swapchain = in_ext->swapchain;
6879             out_ext->imageIndex = in_ext->imageIndex;
6880             out_header->pNext = (void *)out_ext;
6881             out_header = (void *)out_ext;
6882             break;
6883         }
6884         case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
6885         {
6886             VkBindImagePlaneMemoryInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6887             const VkBindImagePlaneMemoryInfo32 *in_ext = (const VkBindImagePlaneMemoryInfo32 *)in_header;
6888             out_ext->sType = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO;
6889             out_ext->pNext = NULL;
6890             out_ext->planeAspect = in_ext->planeAspect;
6891             out_header->pNext = (void *)out_ext;
6892             out_header = (void *)out_ext;
6893             break;
6894         }
6895         default:
6896             FIXME("Unhandled sType %u.\n", in_header->sType);
6897             break;
6898         }
6899     }
6900 }
6901
6902 #ifdef _WIN64
6903 static inline const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo *in, uint32_t count)
6904 {
6905     VkBindImageMemoryInfo *out;
6906     unsigned int i;
6907
6908     if (!in || !count) return NULL;
6909
6910     out = conversion_context_alloc(ctx, count * sizeof(*out));
6911     for (i = 0; i < count; i++)
6912     {
6913         convert_VkBindImageMemoryInfo_win64_to_host(&in[i], &out[i]);
6914     }
6915
6916     return out;
6917 }
6918 #endif /* _WIN64 */
6919
6920 static inline const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, uint32_t count)
6921 {
6922     VkBindImageMemoryInfo *out;
6923     unsigned int i;
6924
6925     if (!in || !count) return NULL;
6926
6927     out = conversion_context_alloc(ctx, count * sizeof(*out));
6928     for (i = 0; i < count; i++)
6929     {
6930         convert_VkBindImageMemoryInfo_win32_to_host(ctx, &in[i], &out[i]);
6931     }
6932
6933     return out;
6934 }
6935
6936 static inline const VkMicromapUsageEXT * const*convert_VkMicromapUsageEXT_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
6937 {
6938     VkMicromapUsageEXT **out;
6939     unsigned int i;
6940
6941     if (!in || !count) return NULL;
6942
6943     out = conversion_context_alloc(ctx, count * sizeof(*out));
6944     for (i = 0; i < count; i++)
6945     {
6946         out[i] = UlongToPtr(in[i]);
6947     }
6948
6949     return (void *)out;
6950 }
6951
6952 static inline void convert_VkAccelerationStructureGeometryTrianglesDataKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryTrianglesDataKHR32 *in, VkAccelerationStructureGeometryTrianglesDataKHR *out)
6953 {
6954     const VkBaseInStructure32 *in_header;
6955     VkBaseOutStructure *out_header = (void *)out;
6956
6957     if (!in) return;
6958
6959     out->sType = in->sType;
6960     out->pNext = NULL;
6961     out->vertexFormat = in->vertexFormat;
6962     out->vertexData = in->vertexData;
6963     out->vertexStride = in->vertexStride;
6964     out->maxVertex = in->maxVertex;
6965     out->indexType = in->indexType;
6966     out->indexData = in->indexData;
6967     out->transformData = in->transformData;
6968
6969     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6970     {
6971         switch (in_header->sType)
6972         {
6973         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
6974         {
6975             VkAccelerationStructureGeometryMotionTrianglesDataNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6976             const VkAccelerationStructureGeometryMotionTrianglesDataNV32 *in_ext = (const VkAccelerationStructureGeometryMotionTrianglesDataNV32 *)in_header;
6977             out_ext->sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV;
6978             out_ext->pNext = NULL;
6979             out_ext->vertexData = in_ext->vertexData;
6980             out_header->pNext = (void *)out_ext;
6981             out_header = (void *)out_ext;
6982             break;
6983         }
6984         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT:
6985         {
6986             VkAccelerationStructureTrianglesOpacityMicromapEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6987             const VkAccelerationStructureTrianglesOpacityMicromapEXT32 *in_ext = (const VkAccelerationStructureTrianglesOpacityMicromapEXT32 *)in_header;
6988             out_ext->sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT;
6989             out_ext->pNext = NULL;
6990             out_ext->indexType = in_ext->indexType;
6991             out_ext->indexBuffer = in_ext->indexBuffer;
6992             out_ext->indexStride = in_ext->indexStride;
6993             out_ext->baseTriangle = in_ext->baseTriangle;
6994             out_ext->usageCountsCount = in_ext->usageCountsCount;
6995             out_ext->pUsageCounts = (const VkMicromapUsageEXT *)UlongToPtr(in_ext->pUsageCounts);
6996             out_ext->ppUsageCounts = convert_VkMicromapUsageEXT_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in_ext->ppUsageCounts), in_ext->usageCountsCount);
6997             out_ext->micromap = in_ext->micromap;
6998             out_header->pNext = (void *)out_ext;
6999             out_header = (void *)out_ext;
7000             break;
7001         }
7002         default:
7003             FIXME("Unhandled sType %u.\n", in_header->sType);
7004             break;
7005         }
7006     }
7007 }
7008
7009 static inline void convert_VkAccelerationStructureGeometryAabbsDataKHR_win32_to_host(const VkAccelerationStructureGeometryAabbsDataKHR32 *in, VkAccelerationStructureGeometryAabbsDataKHR *out)
7010 {
7011     if (!in) return;
7012
7013     out->sType = in->sType;
7014     out->pNext = NULL;
7015     out->data = in->data;
7016     out->stride = in->stride;
7017     if (in->pNext)
7018         FIXME("Unexpected pNext\n");
7019 }
7020
7021 static inline void convert_VkAccelerationStructureGeometryInstancesDataKHR_win32_to_host(const VkAccelerationStructureGeometryInstancesDataKHR32 *in, VkAccelerationStructureGeometryInstancesDataKHR *out)
7022 {
7023     if (!in) return;
7024
7025     out->sType = in->sType;
7026     out->pNext = NULL;
7027     out->arrayOfPointers = in->arrayOfPointers;
7028     out->data = in->data;
7029     if (in->pNext)
7030         FIXME("Unexpected pNext\n");
7031 }
7032
7033 static inline void convert_VkAccelerationStructureGeometryDataKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryDataKHR32 *in, VkAccelerationStructureGeometryDataKHR *out, VkFlags selector)
7034 {
7035     if (!in) return;
7036
7037     if (selector == VK_GEOMETRY_TYPE_TRIANGLES_KHR)
7038         convert_VkAccelerationStructureGeometryTrianglesDataKHR_win32_to_host(ctx, &in->triangles, &out->triangles);
7039     if (selector == VK_GEOMETRY_TYPE_AABBS_KHR)
7040         convert_VkAccelerationStructureGeometryAabbsDataKHR_win32_to_host(&in->aabbs, &out->aabbs);
7041     if (selector == VK_GEOMETRY_TYPE_INSTANCES_KHR)
7042         convert_VkAccelerationStructureGeometryInstancesDataKHR_win32_to_host(&in->instances, &out->instances);
7043 }
7044
7045 static inline void convert_VkAccelerationStructureGeometryKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, VkAccelerationStructureGeometryKHR *out)
7046 {
7047     if (!in) return;
7048
7049     out->sType = in->sType;
7050     out->pNext = NULL;
7051     out->geometryType = in->geometryType;
7052     convert_VkAccelerationStructureGeometryDataKHR_win32_to_host(ctx, &in->geometry, &out->geometry, in->geometryType);
7053     out->flags = in->flags;
7054     if (in->pNext)
7055         FIXME("Unexpected pNext\n");
7056 }
7057
7058 static inline const VkAccelerationStructureGeometryKHR *convert_VkAccelerationStructureGeometryKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, uint32_t count)
7059 {
7060     VkAccelerationStructureGeometryKHR *out;
7061     unsigned int i;
7062
7063     if (!in || !count) return NULL;
7064
7065     out = conversion_context_alloc(ctx, count * sizeof(*out));
7066     for (i = 0; i < count; i++)
7067     {
7068         convert_VkAccelerationStructureGeometryKHR_win32_to_host(ctx, &in[i], &out[i]);
7069     }
7070
7071     return out;
7072 }
7073
7074 static inline const VkAccelerationStructureGeometryKHR * const*convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
7075 {
7076     VkAccelerationStructureGeometryKHR **out;
7077     unsigned int i;
7078
7079     if (!in || !count) return NULL;
7080
7081     out = conversion_context_alloc(ctx, count * sizeof(*out));
7082     for (i = 0; i < count; i++)
7083     {
7084         if (in[i])
7085         {
7086             out[i] = conversion_context_alloc(ctx, sizeof(*out[i]));
7087             convert_VkAccelerationStructureGeometryKHR_win32_to_host(ctx, (VkAccelerationStructureGeometryKHR32 *)UlongToPtr(in[i]), out[i]);
7088         }
7089         else
7090             out[i] = NULL;
7091     }
7092
7093     return (void *)out;
7094 }
7095
7096 static inline void convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, VkAccelerationStructureBuildGeometryInfoKHR *out)
7097 {
7098     if (!in) return;
7099
7100     out->sType = in->sType;
7101     out->pNext = NULL;
7102     out->type = in->type;
7103     out->flags = in->flags;
7104     out->mode = in->mode;
7105     out->srcAccelerationStructure = in->srcAccelerationStructure;
7106     out->dstAccelerationStructure = in->dstAccelerationStructure;
7107     out->geometryCount = in->geometryCount;
7108     out->pGeometries = convert_VkAccelerationStructureGeometryKHR_array_win32_to_host(ctx, (const VkAccelerationStructureGeometryKHR32 *)UlongToPtr(in->pGeometries), in->geometryCount);
7109     out->ppGeometries = convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppGeometries), in->geometryCount);
7110     out->scratchData = in->scratchData;
7111     if (in->pNext)
7112         FIXME("Unexpected pNext\n");
7113 }
7114
7115 static inline const VkAccelerationStructureBuildGeometryInfoKHR *convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, uint32_t count)
7116 {
7117     VkAccelerationStructureBuildGeometryInfoKHR *out;
7118     unsigned int i;
7119
7120     if (!in || !count) return NULL;
7121
7122     out = conversion_context_alloc(ctx, count * sizeof(*out));
7123     for (i = 0; i < count; i++)
7124     {
7125         convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(ctx, &in[i], &out[i]);
7126     }
7127
7128     return out;
7129 }
7130
7131 static inline void convert_VkMicromapBuildInfoEXT_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT32 *in, VkMicromapBuildInfoEXT *out)
7132 {
7133     if (!in) return;
7134
7135     out->sType = in->sType;
7136     out->pNext = NULL;
7137     out->type = in->type;
7138     out->flags = in->flags;
7139     out->mode = in->mode;
7140     out->dstMicromap = in->dstMicromap;
7141     out->usageCountsCount = in->usageCountsCount;
7142     out->pUsageCounts = (const VkMicromapUsageEXT *)UlongToPtr(in->pUsageCounts);
7143     out->ppUsageCounts = convert_VkMicromapUsageEXT_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppUsageCounts), in->usageCountsCount);
7144     out->data = in->data;
7145     out->scratchData = in->scratchData;
7146     out->triangleArray = in->triangleArray;
7147     out->triangleArrayStride = in->triangleArrayStride;
7148     if (in->pNext)
7149         FIXME("Unexpected pNext\n");
7150 }
7151
7152 static inline const VkMicromapBuildInfoEXT *convert_VkMicromapBuildInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT32 *in, uint32_t count)
7153 {
7154     VkMicromapBuildInfoEXT *out;
7155     unsigned int i;
7156
7157     if (!in || !count) return NULL;
7158
7159     out = conversion_context_alloc(ctx, count * sizeof(*out));
7160     for (i = 0; i < count; i++)
7161     {
7162         convert_VkMicromapBuildInfoEXT_win32_to_host(ctx, &in[i], &out[i]);
7163     }
7164
7165     return out;
7166 }
7167
7168 static inline void convert_VkConditionalRenderingBeginInfoEXT_win32_to_host(const VkConditionalRenderingBeginInfoEXT32 *in, VkConditionalRenderingBeginInfoEXT *out)
7169 {
7170     if (!in) return;
7171
7172     out->sType = in->sType;
7173     out->pNext = NULL;
7174     out->buffer = in->buffer;
7175     out->offset = in->offset;
7176     out->flags = in->flags;
7177     if (in->pNext)
7178         FIXME("Unexpected pNext\n");
7179 }
7180
7181 static inline void convert_VkDebugUtilsLabelEXT_win32_to_host(const VkDebugUtilsLabelEXT32 *in, VkDebugUtilsLabelEXT *out)
7182 {
7183     if (!in) return;
7184
7185     out->sType = in->sType;
7186     out->pNext = NULL;
7187     out->pLabelName = (const char *)UlongToPtr(in->pLabelName);
7188     memcpy(out->color, in->color, 4 * sizeof(float));
7189     if (in->pNext)
7190         FIXME("Unexpected pNext\n");
7191 }
7192
7193 static inline void convert_VkSampleLocationsInfoEXT_win32_to_host(const VkSampleLocationsInfoEXT32 *in, VkSampleLocationsInfoEXT *out)
7194 {
7195     if (!in) return;
7196
7197     out->sType = in->sType;
7198     out->pNext = NULL;
7199     out->sampleLocationsPerPixel = in->sampleLocationsPerPixel;
7200     out->sampleLocationGridSize = in->sampleLocationGridSize;
7201     out->sampleLocationsCount = in->sampleLocationsCount;
7202     out->pSampleLocations = (const VkSampleLocationEXT *)UlongToPtr(in->pSampleLocations);
7203     if (in->pNext)
7204         FIXME("Unexpected pNext\n");
7205 }
7206
7207 static inline void convert_VkAttachmentSampleLocationsEXT_win32_to_host(const VkAttachmentSampleLocationsEXT32 *in, VkAttachmentSampleLocationsEXT *out)
7208 {
7209     if (!in) return;
7210
7211     out->attachmentIndex = in->attachmentIndex;
7212     convert_VkSampleLocationsInfoEXT_win32_to_host(&in->sampleLocationsInfo, &out->sampleLocationsInfo);
7213 }
7214
7215 static inline const VkAttachmentSampleLocationsEXT *convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentSampleLocationsEXT32 *in, uint32_t count)
7216 {
7217     VkAttachmentSampleLocationsEXT *out;
7218     unsigned int i;
7219
7220     if (!in || !count) return NULL;
7221
7222     out = conversion_context_alloc(ctx, count * sizeof(*out));
7223     for (i = 0; i < count; i++)
7224     {
7225         convert_VkAttachmentSampleLocationsEXT_win32_to_host(&in[i], &out[i]);
7226     }
7227
7228     return out;
7229 }
7230
7231 static inline void convert_VkSubpassSampleLocationsEXT_win32_to_host(const VkSubpassSampleLocationsEXT32 *in, VkSubpassSampleLocationsEXT *out)
7232 {
7233     if (!in) return;
7234
7235     out->subpassIndex = in->subpassIndex;
7236     convert_VkSampleLocationsInfoEXT_win32_to_host(&in->sampleLocationsInfo, &out->sampleLocationsInfo);
7237 }
7238
7239 static inline const VkSubpassSampleLocationsEXT *convert_VkSubpassSampleLocationsEXT_array_win32_to_host(struct conversion_context *ctx, const VkSubpassSampleLocationsEXT32 *in, uint32_t count)
7240 {
7241     VkSubpassSampleLocationsEXT *out;
7242     unsigned int i;
7243
7244     if (!in || !count) return NULL;
7245
7246     out = conversion_context_alloc(ctx, count * sizeof(*out));
7247     for (i = 0; i < count; i++)
7248     {
7249         convert_VkSubpassSampleLocationsEXT_win32_to_host(&in[i], &out[i]);
7250     }
7251
7252     return out;
7253 }
7254
7255 static inline void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion_context *ctx, const VkRenderPassBeginInfo32 *in, VkRenderPassBeginInfo *out)
7256 {
7257     const VkBaseInStructure32 *in_header;
7258     VkBaseOutStructure *out_header = (void *)out;
7259
7260     if (!in) return;
7261
7262     out->sType = in->sType;
7263     out->pNext = NULL;
7264     out->renderPass = in->renderPass;
7265     out->framebuffer = in->framebuffer;
7266     out->renderArea = in->renderArea;
7267     out->clearValueCount = in->clearValueCount;
7268     out->pClearValues = (const VkClearValue *)UlongToPtr(in->pClearValues);
7269
7270     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7271     {
7272         switch (in_header->sType)
7273         {
7274         case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
7275         {
7276             VkDeviceGroupRenderPassBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7277             const VkDeviceGroupRenderPassBeginInfo32 *in_ext = (const VkDeviceGroupRenderPassBeginInfo32 *)in_header;
7278             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
7279             out_ext->pNext = NULL;
7280             out_ext->deviceMask = in_ext->deviceMask;
7281             out_ext->deviceRenderAreaCount = in_ext->deviceRenderAreaCount;
7282             out_ext->pDeviceRenderAreas = (const VkRect2D *)UlongToPtr(in_ext->pDeviceRenderAreas);
7283             out_header->pNext = (void *)out_ext;
7284             out_header = (void *)out_ext;
7285             break;
7286         }
7287         case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
7288         {
7289             VkRenderPassSampleLocationsBeginInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7290             const VkRenderPassSampleLocationsBeginInfoEXT32 *in_ext = (const VkRenderPassSampleLocationsBeginInfoEXT32 *)in_header;
7291             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT;
7292             out_ext->pNext = NULL;
7293             out_ext->attachmentInitialSampleLocationsCount = in_ext->attachmentInitialSampleLocationsCount;
7294             out_ext->pAttachmentInitialSampleLocations = convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(ctx, (const VkAttachmentSampleLocationsEXT32 *)UlongToPtr(in_ext->pAttachmentInitialSampleLocations), in_ext->attachmentInitialSampleLocationsCount);
7295             out_ext->postSubpassSampleLocationsCount = in_ext->postSubpassSampleLocationsCount;
7296             out_ext->pPostSubpassSampleLocations = convert_VkSubpassSampleLocationsEXT_array_win32_to_host(ctx, (const VkSubpassSampleLocationsEXT32 *)UlongToPtr(in_ext->pPostSubpassSampleLocations), in_ext->postSubpassSampleLocationsCount);
7297             out_header->pNext = (void *)out_ext;
7298             out_header = (void *)out_ext;
7299             break;
7300         }
7301         case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
7302         {
7303             VkRenderPassAttachmentBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7304             const VkRenderPassAttachmentBeginInfo32 *in_ext = (const VkRenderPassAttachmentBeginInfo32 *)in_header;
7305             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO;
7306             out_ext->pNext = NULL;
7307             out_ext->attachmentCount = in_ext->attachmentCount;
7308             out_ext->pAttachments = (const VkImageView *)UlongToPtr(in_ext->pAttachments);
7309             out_header->pNext = (void *)out_ext;
7310             out_header = (void *)out_ext;
7311             break;
7312         }
7313         case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
7314         {
7315             VkRenderPassTransformBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7316             const VkRenderPassTransformBeginInfoQCOM32 *in_ext = (const VkRenderPassTransformBeginInfoQCOM32 *)in_header;
7317             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM;
7318             out_ext->pNext = NULL;
7319             out_ext->transform = in_ext->transform;
7320             out_header->pNext = (void *)out_ext;
7321             out_header = (void *)out_ext;
7322             break;
7323         }
7324         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
7325         {
7326             VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7327             const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *in_ext = (const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *)in_header;
7328             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM;
7329             out_ext->pNext = NULL;
7330             out_ext->perViewRenderAreaCount = in_ext->perViewRenderAreaCount;
7331             out_ext->pPerViewRenderAreas = (const VkRect2D *)UlongToPtr(in_ext->pPerViewRenderAreas);
7332             out_header->pNext = (void *)out_ext;
7333             out_header = (void *)out_ext;
7334             break;
7335         }
7336         default:
7337             FIXME("Unhandled sType %u.\n", in_header->sType);
7338             break;
7339         }
7340     }
7341 }
7342
7343 static inline void convert_VkSubpassBeginInfo_win32_to_host(const VkSubpassBeginInfo32 *in, VkSubpassBeginInfo *out)
7344 {
7345     if (!in) return;
7346
7347     out->sType = in->sType;
7348     out->pNext = NULL;
7349     out->contents = in->contents;
7350     if (in->pNext)
7351         FIXME("Unexpected pNext\n");
7352 }
7353
7354 static inline void convert_VkRenderingAttachmentInfo_win32_to_host(const VkRenderingAttachmentInfo32 *in, VkRenderingAttachmentInfo *out)
7355 {
7356     if (!in) return;
7357
7358     out->sType = in->sType;
7359     out->pNext = NULL;
7360     out->imageView = in->imageView;
7361     out->imageLayout = in->imageLayout;
7362     out->resolveMode = in->resolveMode;
7363     out->resolveImageView = in->resolveImageView;
7364     out->resolveImageLayout = in->resolveImageLayout;
7365     out->loadOp = in->loadOp;
7366     out->storeOp = in->storeOp;
7367     out->clearValue = in->clearValue;
7368     if (in->pNext)
7369         FIXME("Unexpected pNext\n");
7370 }
7371
7372 static inline const VkRenderingAttachmentInfo *convert_VkRenderingAttachmentInfo_array_win32_to_host(struct conversion_context *ctx, const VkRenderingAttachmentInfo32 *in, uint32_t count)
7373 {
7374     VkRenderingAttachmentInfo *out;
7375     unsigned int i;
7376
7377     if (!in || !count) return NULL;
7378
7379     out = conversion_context_alloc(ctx, count * sizeof(*out));
7380     for (i = 0; i < count; i++)
7381     {
7382         convert_VkRenderingAttachmentInfo_win32_to_host(&in[i], &out[i]);
7383     }
7384
7385     return out;
7386 }
7387
7388 static inline void convert_VkRenderingInfo_win32_to_host(struct conversion_context *ctx, const VkRenderingInfo32 *in, VkRenderingInfo *out)
7389 {
7390     const VkBaseInStructure32 *in_header;
7391     VkBaseOutStructure *out_header = (void *)out;
7392
7393     if (!in) return;
7394
7395     out->sType = in->sType;
7396     out->pNext = NULL;
7397     out->flags = in->flags;
7398     out->renderArea = in->renderArea;
7399     out->layerCount = in->layerCount;
7400     out->viewMask = in->viewMask;
7401     out->colorAttachmentCount = in->colorAttachmentCount;
7402     out->pColorAttachments = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, (const VkRenderingAttachmentInfo32 *)UlongToPtr(in->pColorAttachments), in->colorAttachmentCount);
7403     out->pDepthAttachment = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, (const VkRenderingAttachmentInfo32 *)UlongToPtr(in->pDepthAttachment), 1);
7404     out->pStencilAttachment = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, (const VkRenderingAttachmentInfo32 *)UlongToPtr(in->pStencilAttachment), 1);
7405
7406     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7407     {
7408         switch (in_header->sType)
7409         {
7410         case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
7411         {
7412             VkDeviceGroupRenderPassBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7413             const VkDeviceGroupRenderPassBeginInfo32 *in_ext = (const VkDeviceGroupRenderPassBeginInfo32 *)in_header;
7414             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
7415             out_ext->pNext = NULL;
7416             out_ext->deviceMask = in_ext->deviceMask;
7417             out_ext->deviceRenderAreaCount = in_ext->deviceRenderAreaCount;
7418             out_ext->pDeviceRenderAreas = (const VkRect2D *)UlongToPtr(in_ext->pDeviceRenderAreas);
7419             out_header->pNext = (void *)out_ext;
7420             out_header = (void *)out_ext;
7421             break;
7422         }
7423         case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
7424         {
7425             VkMultisampledRenderToSingleSampledInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7426             const VkMultisampledRenderToSingleSampledInfoEXT32 *in_ext = (const VkMultisampledRenderToSingleSampledInfoEXT32 *)in_header;
7427             out_ext->sType = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT;
7428             out_ext->pNext = NULL;
7429             out_ext->multisampledRenderToSingleSampledEnable = in_ext->multisampledRenderToSingleSampledEnable;
7430             out_ext->rasterizationSamples = in_ext->rasterizationSamples;
7431             out_header->pNext = (void *)out_ext;
7432             out_header = (void *)out_ext;
7433             break;
7434         }
7435         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
7436         {
7437             VkRenderingFragmentShadingRateAttachmentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7438             const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *in_ext = (const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *)in_header;
7439             out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
7440             out_ext->pNext = NULL;
7441             out_ext->imageView = in_ext->imageView;
7442             out_ext->imageLayout = in_ext->imageLayout;
7443             out_ext->shadingRateAttachmentTexelSize = in_ext->shadingRateAttachmentTexelSize;
7444             out_header->pNext = (void *)out_ext;
7445             out_header = (void *)out_ext;
7446             break;
7447         }
7448         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
7449         {
7450             VkRenderingFragmentDensityMapAttachmentInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7451             const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *in_ext = (const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *)in_header;
7452             out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT;
7453             out_ext->pNext = NULL;
7454             out_ext->imageView = in_ext->imageView;
7455             out_ext->imageLayout = in_ext->imageLayout;
7456             out_header->pNext = (void *)out_ext;
7457             out_header = (void *)out_ext;
7458             break;
7459         }
7460         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
7461         {
7462             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7463             const VkMultiviewPerViewAttributesInfoNVX32 *in_ext = (const VkMultiviewPerViewAttributesInfoNVX32 *)in_header;
7464             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
7465             out_ext->pNext = NULL;
7466             out_ext->perViewAttributes = in_ext->perViewAttributes;
7467             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
7468             out_header->pNext = (void *)out_ext;
7469             out_header = (void *)out_ext;
7470             break;
7471         }
7472         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
7473         {
7474             VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7475             const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *in_ext = (const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *)in_header;
7476             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM;
7477             out_ext->pNext = NULL;
7478             out_ext->perViewRenderAreaCount = in_ext->perViewRenderAreaCount;
7479             out_ext->pPerViewRenderAreas = (const VkRect2D *)UlongToPtr(in_ext->pPerViewRenderAreas);
7480             out_header->pNext = (void *)out_ext;
7481             out_header = (void *)out_ext;
7482             break;
7483         }
7484         default:
7485             FIXME("Unhandled sType %u.\n", in_header->sType);
7486             break;
7487         }
7488     }
7489 }
7490
7491 static inline void convert_VkDescriptorBufferBindingInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferBindingInfoEXT32 *in, VkDescriptorBufferBindingInfoEXT *out)
7492 {
7493     const VkBaseInStructure32 *in_header;
7494     VkBaseOutStructure *out_header = (void *)out;
7495
7496     if (!in) return;
7497
7498     out->sType = in->sType;
7499     out->pNext = NULL;
7500     out->address = in->address;
7501     out->usage = in->usage;
7502
7503     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7504     {
7505         switch (in_header->sType)
7506         {
7507         case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT:
7508         {
7509             VkDescriptorBufferBindingPushDescriptorBufferHandleEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7510             const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32 *in_ext = (const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32 *)in_header;
7511             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT;
7512             out_ext->pNext = NULL;
7513             out_ext->buffer = in_ext->buffer;
7514             out_header->pNext = (void *)out_ext;
7515             out_header = (void *)out_ext;
7516             break;
7517         }
7518         default:
7519             FIXME("Unhandled sType %u.\n", in_header->sType);
7520             break;
7521         }
7522     }
7523 }
7524
7525 static inline const VkDescriptorBufferBindingInfoEXT *convert_VkDescriptorBufferBindingInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferBindingInfoEXT32 *in, uint32_t count)
7526 {
7527     VkDescriptorBufferBindingInfoEXT *out;
7528     unsigned int i;
7529
7530     if (!in || !count) return NULL;
7531
7532     out = conversion_context_alloc(ctx, count * sizeof(*out));
7533     for (i = 0; i < count; i++)
7534     {
7535         convert_VkDescriptorBufferBindingInfoEXT_win32_to_host(ctx, &in[i], &out[i]);
7536     }
7537
7538     return out;
7539 }
7540
7541 static inline void convert_VkImageBlit2_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, VkImageBlit2 *out)
7542 {
7543     const VkBaseInStructure32 *in_header;
7544     VkBaseOutStructure *out_header = (void *)out;
7545
7546     if (!in) return;
7547
7548     out->sType = in->sType;
7549     out->pNext = NULL;
7550     out->srcSubresource = in->srcSubresource;
7551     memcpy(out->srcOffsets, in->srcOffsets, 2 * sizeof(VkOffset3D));
7552     out->dstSubresource = in->dstSubresource;
7553     memcpy(out->dstOffsets, in->dstOffsets, 2 * sizeof(VkOffset3D));
7554
7555     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7556     {
7557         switch (in_header->sType)
7558         {
7559         case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
7560         {
7561             VkCopyCommandTransformInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7562             const VkCopyCommandTransformInfoQCOM32 *in_ext = (const VkCopyCommandTransformInfoQCOM32 *)in_header;
7563             out_ext->sType = VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM;
7564             out_ext->pNext = NULL;
7565             out_ext->transform = in_ext->transform;
7566             out_header->pNext = (void *)out_ext;
7567             out_header = (void *)out_ext;
7568             break;
7569         }
7570         default:
7571             FIXME("Unhandled sType %u.\n", in_header->sType);
7572             break;
7573         }
7574     }
7575 }
7576
7577 static inline const VkImageBlit2 *convert_VkImageBlit2_array_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, uint32_t count)
7578 {
7579     VkImageBlit2 *out;
7580     unsigned int i;
7581
7582     if (!in || !count) return NULL;
7583
7584     out = conversion_context_alloc(ctx, count * sizeof(*out));
7585     for (i = 0; i < count; i++)
7586     {
7587         convert_VkImageBlit2_win32_to_host(ctx, &in[i], &out[i]);
7588     }
7589
7590     return out;
7591 }
7592
7593 static inline void convert_VkBlitImageInfo2_win32_to_host(struct conversion_context *ctx, const VkBlitImageInfo232 *in, VkBlitImageInfo2 *out)
7594 {
7595     if (!in) return;
7596
7597     out->sType = in->sType;
7598     out->pNext = NULL;
7599     out->srcImage = in->srcImage;
7600     out->srcImageLayout = in->srcImageLayout;
7601     out->dstImage = in->dstImage;
7602     out->dstImageLayout = in->dstImageLayout;
7603     out->regionCount = in->regionCount;
7604     out->pRegions = convert_VkImageBlit2_array_win32_to_host(ctx, (const VkImageBlit232 *)UlongToPtr(in->pRegions), in->regionCount);
7605     out->filter = in->filter;
7606     if (in->pNext)
7607         FIXME("Unexpected pNext\n");
7608 }
7609
7610 static inline void convert_VkGeometryTrianglesNV_win32_to_host(const VkGeometryTrianglesNV32 *in, VkGeometryTrianglesNV *out)
7611 {
7612     if (!in) return;
7613
7614     out->sType = in->sType;
7615     out->pNext = NULL;
7616     out->vertexData = in->vertexData;
7617     out->vertexOffset = in->vertexOffset;
7618     out->vertexCount = in->vertexCount;
7619     out->vertexStride = in->vertexStride;
7620     out->vertexFormat = in->vertexFormat;
7621     out->indexData = in->indexData;
7622     out->indexOffset = in->indexOffset;
7623     out->indexCount = in->indexCount;
7624     out->indexType = in->indexType;
7625     out->transformData = in->transformData;
7626     out->transformOffset = in->transformOffset;
7627     if (in->pNext)
7628         FIXME("Unexpected pNext\n");
7629 }
7630
7631 static inline void convert_VkGeometryAABBNV_win32_to_host(const VkGeometryAABBNV32 *in, VkGeometryAABBNV *out)
7632 {
7633     if (!in) return;
7634
7635     out->sType = in->sType;
7636     out->pNext = NULL;
7637     out->aabbData = in->aabbData;
7638     out->numAABBs = in->numAABBs;
7639     out->stride = in->stride;
7640     out->offset = in->offset;
7641     if (in->pNext)
7642         FIXME("Unexpected pNext\n");
7643 }
7644
7645 static inline void convert_VkGeometryDataNV_win32_to_host(const VkGeometryDataNV32 *in, VkGeometryDataNV *out)
7646 {
7647     if (!in) return;
7648
7649     convert_VkGeometryTrianglesNV_win32_to_host(&in->triangles, &out->triangles);
7650     convert_VkGeometryAABBNV_win32_to_host(&in->aabbs, &out->aabbs);
7651 }
7652
7653 static inline void convert_VkGeometryNV_win32_to_host(const VkGeometryNV32 *in, VkGeometryNV *out)
7654 {
7655     if (!in) return;
7656
7657     out->sType = in->sType;
7658     out->pNext = NULL;
7659     out->geometryType = in->geometryType;
7660     convert_VkGeometryDataNV_win32_to_host(&in->geometry, &out->geometry);
7661     out->flags = in->flags;
7662     if (in->pNext)
7663         FIXME("Unexpected pNext\n");
7664 }
7665
7666 static inline const VkGeometryNV *convert_VkGeometryNV_array_win32_to_host(struct conversion_context *ctx, const VkGeometryNV32 *in, uint32_t count)
7667 {
7668     VkGeometryNV *out;
7669     unsigned int i;
7670
7671     if (!in || !count) return NULL;
7672
7673     out = conversion_context_alloc(ctx, count * sizeof(*out));
7674     for (i = 0; i < count; i++)
7675     {
7676         convert_VkGeometryNV_win32_to_host(&in[i], &out[i]);
7677     }
7678
7679     return out;
7680 }
7681
7682 static inline void convert_VkAccelerationStructureInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureInfoNV32 *in, VkAccelerationStructureInfoNV *out)
7683 {
7684     if (!in) return;
7685
7686     out->sType = in->sType;
7687     out->pNext = NULL;
7688     out->type = in->type;
7689     out->flags = in->flags;
7690     out->instanceCount = in->instanceCount;
7691     out->geometryCount = in->geometryCount;
7692     out->pGeometries = convert_VkGeometryNV_array_win32_to_host(ctx, (const VkGeometryNV32 *)UlongToPtr(in->pGeometries), in->geometryCount);
7693     if (in->pNext)
7694         FIXME("Unexpected pNext\n");
7695 }
7696
7697 static inline void convert_VkCopyAccelerationStructureInfoKHR_win32_to_host(const VkCopyAccelerationStructureInfoKHR32 *in, VkCopyAccelerationStructureInfoKHR *out)
7698 {
7699     if (!in) return;
7700
7701     out->sType = in->sType;
7702     out->pNext = NULL;
7703     out->src = in->src;
7704     out->dst = in->dst;
7705     out->mode = in->mode;
7706     if (in->pNext)
7707         FIXME("Unexpected pNext\n");
7708 }
7709
7710 static inline void convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host(const VkCopyAccelerationStructureToMemoryInfoKHR32 *in, VkCopyAccelerationStructureToMemoryInfoKHR *out)
7711 {
7712     if (!in) return;
7713
7714     out->sType = in->sType;
7715     out->pNext = NULL;
7716     out->src = in->src;
7717     out->dst = in->dst;
7718     out->mode = in->mode;
7719     if (in->pNext)
7720         FIXME("Unexpected pNext\n");
7721 }
7722
7723 static inline void convert_VkBufferCopy_win32_to_host(const VkBufferCopy32 *in, VkBufferCopy *out)
7724 {
7725     if (!in) return;
7726
7727     out->srcOffset = in->srcOffset;
7728     out->dstOffset = in->dstOffset;
7729     out->size = in->size;
7730 }
7731
7732 static inline const VkBufferCopy *convert_VkBufferCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy32 *in, uint32_t count)
7733 {
7734     VkBufferCopy *out;
7735     unsigned int i;
7736
7737     if (!in || !count) return NULL;
7738
7739     out = conversion_context_alloc(ctx, count * sizeof(*out));
7740     for (i = 0; i < count; i++)
7741     {
7742         convert_VkBufferCopy_win32_to_host(&in[i], &out[i]);
7743     }
7744
7745     return out;
7746 }
7747
7748 static inline void convert_VkBufferCopy2_win32_to_host(const VkBufferCopy232 *in, VkBufferCopy2 *out)
7749 {
7750     if (!in) return;
7751
7752     out->sType = in->sType;
7753     out->pNext = NULL;
7754     out->srcOffset = in->srcOffset;
7755     out->dstOffset = in->dstOffset;
7756     out->size = in->size;
7757     if (in->pNext)
7758         FIXME("Unexpected pNext\n");
7759 }
7760
7761 static inline const VkBufferCopy2 *convert_VkBufferCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy232 *in, uint32_t count)
7762 {
7763     VkBufferCopy2 *out;
7764     unsigned int i;
7765
7766     if (!in || !count) return NULL;
7767
7768     out = conversion_context_alloc(ctx, count * sizeof(*out));
7769     for (i = 0; i < count; i++)
7770     {
7771         convert_VkBufferCopy2_win32_to_host(&in[i], &out[i]);
7772     }
7773
7774     return out;
7775 }
7776
7777 static inline void convert_VkCopyBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferInfo232 *in, VkCopyBufferInfo2 *out)
7778 {
7779     if (!in) return;
7780
7781     out->sType = in->sType;
7782     out->pNext = NULL;
7783     out->srcBuffer = in->srcBuffer;
7784     out->dstBuffer = in->dstBuffer;
7785     out->regionCount = in->regionCount;
7786     out->pRegions = convert_VkBufferCopy2_array_win32_to_host(ctx, (const VkBufferCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
7787     if (in->pNext)
7788         FIXME("Unexpected pNext\n");
7789 }
7790
7791 static inline void convert_VkBufferImageCopy_win32_to_host(const VkBufferImageCopy32 *in, VkBufferImageCopy *out)
7792 {
7793     if (!in) return;
7794
7795     out->bufferOffset = in->bufferOffset;
7796     out->bufferRowLength = in->bufferRowLength;
7797     out->bufferImageHeight = in->bufferImageHeight;
7798     out->imageSubresource = in->imageSubresource;
7799     out->imageOffset = in->imageOffset;
7800     out->imageExtent = in->imageExtent;
7801 }
7802
7803 static inline const VkBufferImageCopy *convert_VkBufferImageCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy32 *in, uint32_t count)
7804 {
7805     VkBufferImageCopy *out;
7806     unsigned int i;
7807
7808     if (!in || !count) return NULL;
7809
7810     out = conversion_context_alloc(ctx, count * sizeof(*out));
7811     for (i = 0; i < count; i++)
7812     {
7813         convert_VkBufferImageCopy_win32_to_host(&in[i], &out[i]);
7814     }
7815
7816     return out;
7817 }
7818
7819 static inline void convert_VkBufferImageCopy2_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy232 *in, VkBufferImageCopy2 *out)
7820 {
7821     const VkBaseInStructure32 *in_header;
7822     VkBaseOutStructure *out_header = (void *)out;
7823
7824     if (!in) return;
7825
7826     out->sType = in->sType;
7827     out->pNext = NULL;
7828     out->bufferOffset = in->bufferOffset;
7829     out->bufferRowLength = in->bufferRowLength;
7830     out->bufferImageHeight = in->bufferImageHeight;
7831     out->imageSubresource = in->imageSubresource;
7832     out->imageOffset = in->imageOffset;
7833     out->imageExtent = in->imageExtent;
7834
7835     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7836     {
7837         switch (in_header->sType)
7838         {
7839         case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
7840         {
7841             VkCopyCommandTransformInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7842             const VkCopyCommandTransformInfoQCOM32 *in_ext = (const VkCopyCommandTransformInfoQCOM32 *)in_header;
7843             out_ext->sType = VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM;
7844             out_ext->pNext = NULL;
7845             out_ext->transform = in_ext->transform;
7846             out_header->pNext = (void *)out_ext;
7847             out_header = (void *)out_ext;
7848             break;
7849         }
7850         default:
7851             FIXME("Unhandled sType %u.\n", in_header->sType);
7852             break;
7853         }
7854     }
7855 }
7856
7857 static inline const VkBufferImageCopy2 *convert_VkBufferImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy232 *in, uint32_t count)
7858 {
7859     VkBufferImageCopy2 *out;
7860     unsigned int i;
7861
7862     if (!in || !count) return NULL;
7863
7864     out = conversion_context_alloc(ctx, count * sizeof(*out));
7865     for (i = 0; i < count; i++)
7866     {
7867         convert_VkBufferImageCopy2_win32_to_host(ctx, &in[i], &out[i]);
7868     }
7869
7870     return out;
7871 }
7872
7873 static inline void convert_VkCopyBufferToImageInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferToImageInfo232 *in, VkCopyBufferToImageInfo2 *out)
7874 {
7875     if (!in) return;
7876
7877     out->sType = in->sType;
7878     out->pNext = NULL;
7879     out->srcBuffer = in->srcBuffer;
7880     out->dstImage = in->dstImage;
7881     out->dstImageLayout = in->dstImageLayout;
7882     out->regionCount = in->regionCount;
7883     out->pRegions = convert_VkBufferImageCopy2_array_win32_to_host(ctx, (const VkBufferImageCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
7884     if (in->pNext)
7885         FIXME("Unexpected pNext\n");
7886 }
7887
7888 static inline void convert_VkImageCopy2_win32_to_host(const VkImageCopy232 *in, VkImageCopy2 *out)
7889 {
7890     if (!in) return;
7891
7892     out->sType = in->sType;
7893     out->pNext = NULL;
7894     out->srcSubresource = in->srcSubresource;
7895     out->srcOffset = in->srcOffset;
7896     out->dstSubresource = in->dstSubresource;
7897     out->dstOffset = in->dstOffset;
7898     out->extent = in->extent;
7899     if (in->pNext)
7900         FIXME("Unexpected pNext\n");
7901 }
7902
7903 static inline const VkImageCopy2 *convert_VkImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkImageCopy232 *in, uint32_t count)
7904 {
7905     VkImageCopy2 *out;
7906     unsigned int i;
7907
7908     if (!in || !count) return NULL;
7909
7910     out = conversion_context_alloc(ctx, count * sizeof(*out));
7911     for (i = 0; i < count; i++)
7912     {
7913         convert_VkImageCopy2_win32_to_host(&in[i], &out[i]);
7914     }
7915
7916     return out;
7917 }
7918
7919 static inline void convert_VkCopyImageInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyImageInfo232 *in, VkCopyImageInfo2 *out)
7920 {
7921     if (!in) return;
7922
7923     out->sType = in->sType;
7924     out->pNext = NULL;
7925     out->srcImage = in->srcImage;
7926     out->srcImageLayout = in->srcImageLayout;
7927     out->dstImage = in->dstImage;
7928     out->dstImageLayout = in->dstImageLayout;
7929     out->regionCount = in->regionCount;
7930     out->pRegions = convert_VkImageCopy2_array_win32_to_host(ctx, (const VkImageCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
7931     if (in->pNext)
7932         FIXME("Unexpected pNext\n");
7933 }
7934
7935 static inline void convert_VkCopyImageToBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyImageToBufferInfo232 *in, VkCopyImageToBufferInfo2 *out)
7936 {
7937     if (!in) return;
7938
7939     out->sType = in->sType;
7940     out->pNext = NULL;
7941     out->srcImage = in->srcImage;
7942     out->srcImageLayout = in->srcImageLayout;
7943     out->dstBuffer = in->dstBuffer;
7944     out->regionCount = in->regionCount;
7945     out->pRegions = convert_VkBufferImageCopy2_array_win32_to_host(ctx, (const VkBufferImageCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
7946     if (in->pNext)
7947         FIXME("Unexpected pNext\n");
7948 }
7949
7950 static inline void convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host(const VkCopyMemoryToAccelerationStructureInfoKHR32 *in, VkCopyMemoryToAccelerationStructureInfoKHR *out)
7951 {
7952     if (!in) return;
7953
7954     out->sType = in->sType;
7955     out->pNext = NULL;
7956     out->src = in->src;
7957     out->dst = in->dst;
7958     out->mode = in->mode;
7959     if (in->pNext)
7960         FIXME("Unexpected pNext\n");
7961 }
7962
7963 static inline void convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(const VkCopyMemoryToMicromapInfoEXT32 *in, VkCopyMemoryToMicromapInfoEXT *out)
7964 {
7965     if (!in) return;
7966
7967     out->sType = in->sType;
7968     out->pNext = NULL;
7969     out->src = in->src;
7970     out->dst = in->dst;
7971     out->mode = in->mode;
7972     if (in->pNext)
7973         FIXME("Unexpected pNext\n");
7974 }
7975
7976 static inline void convert_VkCopyMicromapInfoEXT_win32_to_host(const VkCopyMicromapInfoEXT32 *in, VkCopyMicromapInfoEXT *out)
7977 {
7978     if (!in) return;
7979
7980     out->sType = in->sType;
7981     out->pNext = NULL;
7982     out->src = in->src;
7983     out->dst = in->dst;
7984     out->mode = in->mode;
7985     if (in->pNext)
7986         FIXME("Unexpected pNext\n");
7987 }
7988
7989 static inline void convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(const VkCopyMicromapToMemoryInfoEXT32 *in, VkCopyMicromapToMemoryInfoEXT *out)
7990 {
7991     if (!in) return;
7992
7993     out->sType = in->sType;
7994     out->pNext = NULL;
7995     out->src = in->src;
7996     out->dst = in->dst;
7997     out->mode = in->mode;
7998     if (in->pNext)
7999         FIXME("Unexpected pNext\n");
8000 }
8001
8002 static inline void convert_VkCuLaunchInfoNVX_win32_to_host(const VkCuLaunchInfoNVX32 *in, VkCuLaunchInfoNVX *out)
8003 {
8004     if (!in) return;
8005
8006     out->sType = in->sType;
8007     out->pNext = NULL;
8008     out->function = in->function;
8009     out->gridDimX = in->gridDimX;
8010     out->gridDimY = in->gridDimY;
8011     out->gridDimZ = in->gridDimZ;
8012     out->blockDimX = in->blockDimX;
8013     out->blockDimY = in->blockDimY;
8014     out->blockDimZ = in->blockDimZ;
8015     out->sharedMemBytes = in->sharedMemBytes;
8016     out->paramCount = in->paramCount;
8017     out->pParams = (const void * const *)UlongToPtr(in->pParams);
8018     out->extraCount = in->extraCount;
8019     out->pExtras = (const void * const *)UlongToPtr(in->pExtras);
8020     if (in->pNext)
8021         FIXME("Unexpected pNext\n");
8022 }
8023
8024 static inline void convert_VkDebugMarkerMarkerInfoEXT_win32_to_host(const VkDebugMarkerMarkerInfoEXT32 *in, VkDebugMarkerMarkerInfoEXT *out)
8025 {
8026     if (!in) return;
8027
8028     out->sType = in->sType;
8029     out->pNext = NULL;
8030     out->pMarkerName = (const char *)UlongToPtr(in->pMarkerName);
8031     memcpy(out->color, in->color, 4 * sizeof(float));
8032     if (in->pNext)
8033         FIXME("Unexpected pNext\n");
8034 }
8035
8036 static inline void convert_VkDecompressMemoryRegionNV_win32_to_host(const VkDecompressMemoryRegionNV32 *in, VkDecompressMemoryRegionNV *out)
8037 {
8038     if (!in) return;
8039
8040     out->srcAddress = in->srcAddress;
8041     out->dstAddress = in->dstAddress;
8042     out->compressedSize = in->compressedSize;
8043     out->decompressedSize = in->decompressedSize;
8044     out->decompressionMethod = in->decompressionMethod;
8045 }
8046
8047 static inline const VkDecompressMemoryRegionNV *convert_VkDecompressMemoryRegionNV_array_win32_to_host(struct conversion_context *ctx, const VkDecompressMemoryRegionNV32 *in, uint32_t count)
8048 {
8049     VkDecompressMemoryRegionNV *out;
8050     unsigned int i;
8051
8052     if (!in || !count) return NULL;
8053
8054     out = conversion_context_alloc(ctx, count * sizeof(*out));
8055     for (i = 0; i < count; i++)
8056     {
8057         convert_VkDecompressMemoryRegionNV_win32_to_host(&in[i], &out[i]);
8058     }
8059
8060     return out;
8061 }
8062
8063 static inline void convert_VkSubpassEndInfo_win32_to_host(struct conversion_context *ctx, const VkSubpassEndInfo32 *in, VkSubpassEndInfo *out)
8064 {
8065     const VkBaseInStructure32 *in_header;
8066     VkBaseOutStructure *out_header = (void *)out;
8067
8068     if (!in) return;
8069
8070     out->sType = in->sType;
8071     out->pNext = NULL;
8072
8073     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8074     {
8075         switch (in_header->sType)
8076         {
8077         case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM:
8078         {
8079             VkSubpassFragmentDensityMapOffsetEndInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8080             const VkSubpassFragmentDensityMapOffsetEndInfoQCOM32 *in_ext = (const VkSubpassFragmentDensityMapOffsetEndInfoQCOM32 *)in_header;
8081             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM;
8082             out_ext->pNext = NULL;
8083             out_ext->fragmentDensityOffsetCount = in_ext->fragmentDensityOffsetCount;
8084             out_ext->pFragmentDensityOffsets = (const VkOffset2D *)UlongToPtr(in_ext->pFragmentDensityOffsets);
8085             out_header->pNext = (void *)out_ext;
8086             out_header = (void *)out_ext;
8087             break;
8088         }
8089         default:
8090             FIXME("Unhandled sType %u.\n", in_header->sType);
8091             break;
8092         }
8093     }
8094 }
8095
8096 #ifdef _WIN64
8097 static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win64_to_host(struct conversion_context *ctx, const VkCommandBuffer *in, uint32_t count)
8098 {
8099     VkCommandBuffer *out;
8100     unsigned int i;
8101
8102     if (!in || !count) return NULL;
8103
8104     out = conversion_context_alloc(ctx, count * sizeof(*out));
8105     for (i = 0; i < count; i++)
8106     {
8107         out[i] = wine_cmd_buffer_from_handle(in[i])->command_buffer;
8108     }
8109
8110     return out;
8111 }
8112 #endif /* _WIN64 */
8113
8114 static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
8115 {
8116     VkCommandBuffer *out;
8117     unsigned int i;
8118
8119     if (!in || !count) return NULL;
8120
8121     out = conversion_context_alloc(ctx, count * sizeof(*out));
8122     for (i = 0; i < count; i++)
8123     {
8124         out[i] = wine_cmd_buffer_from_handle(UlongToPtr(in[i]))->command_buffer;
8125     }
8126
8127     return out;
8128 }
8129
8130 static inline void convert_VkIndirectCommandsStreamNV_win32_to_host(const VkIndirectCommandsStreamNV32 *in, VkIndirectCommandsStreamNV *out)
8131 {
8132     if (!in) return;
8133
8134     out->buffer = in->buffer;
8135     out->offset = in->offset;
8136 }
8137
8138 static inline const VkIndirectCommandsStreamNV *convert_VkIndirectCommandsStreamNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsStreamNV32 *in, uint32_t count)
8139 {
8140     VkIndirectCommandsStreamNV *out;
8141     unsigned int i;
8142
8143     if (!in || !count) return NULL;
8144
8145     out = conversion_context_alloc(ctx, count * sizeof(*out));
8146     for (i = 0; i < count; i++)
8147     {
8148         convert_VkIndirectCommandsStreamNV_win32_to_host(&in[i], &out[i]);
8149     }
8150
8151     return out;
8152 }
8153
8154 static inline void convert_VkGeneratedCommandsInfoNV_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsInfoNV32 *in, VkGeneratedCommandsInfoNV *out)
8155 {
8156     if (!in) return;
8157
8158     out->sType = in->sType;
8159     out->pNext = NULL;
8160     out->pipelineBindPoint = in->pipelineBindPoint;
8161     out->pipeline = in->pipeline;
8162     out->indirectCommandsLayout = in->indirectCommandsLayout;
8163     out->streamCount = in->streamCount;
8164     out->pStreams = convert_VkIndirectCommandsStreamNV_array_win32_to_host(ctx, (const VkIndirectCommandsStreamNV32 *)UlongToPtr(in->pStreams), in->streamCount);
8165     out->sequencesCount = in->sequencesCount;
8166     out->preprocessBuffer = in->preprocessBuffer;
8167     out->preprocessOffset = in->preprocessOffset;
8168     out->preprocessSize = in->preprocessSize;
8169     out->sequencesCountBuffer = in->sequencesCountBuffer;
8170     out->sequencesCountOffset = in->sequencesCountOffset;
8171     out->sequencesIndexBuffer = in->sequencesIndexBuffer;
8172     out->sequencesIndexOffset = in->sequencesIndexOffset;
8173     if (in->pNext)
8174         FIXME("Unexpected pNext\n");
8175 }
8176
8177 static inline void convert_VkOpticalFlowExecuteInfoNV_win32_to_host(const VkOpticalFlowExecuteInfoNV32 *in, VkOpticalFlowExecuteInfoNV *out)
8178 {
8179     if (!in) return;
8180
8181     out->sType = in->sType;
8182     out->pNext = NULL;
8183     out->flags = in->flags;
8184     out->regionCount = in->regionCount;
8185     out->pRegions = (const VkRect2D *)UlongToPtr(in->pRegions);
8186     if (in->pNext)
8187         FIXME("Unexpected pNext\n");
8188 }
8189
8190 static inline void convert_VkMemoryBarrier_win32_to_host(const VkMemoryBarrier32 *in, VkMemoryBarrier *out)
8191 {
8192     if (!in) return;
8193
8194     out->sType = in->sType;
8195     out->pNext = NULL;
8196     out->srcAccessMask = in->srcAccessMask;
8197     out->dstAccessMask = in->dstAccessMask;
8198     if (in->pNext)
8199         FIXME("Unexpected pNext\n");
8200 }
8201
8202 static inline const VkMemoryBarrier *convert_VkMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkMemoryBarrier32 *in, uint32_t count)
8203 {
8204     VkMemoryBarrier *out;
8205     unsigned int i;
8206
8207     if (!in || !count) return NULL;
8208
8209     out = conversion_context_alloc(ctx, count * sizeof(*out));
8210     for (i = 0; i < count; i++)
8211     {
8212         convert_VkMemoryBarrier_win32_to_host(&in[i], &out[i]);
8213     }
8214
8215     return out;
8216 }
8217
8218 static inline void convert_VkBufferMemoryBarrier_win32_to_host(const VkBufferMemoryBarrier32 *in, VkBufferMemoryBarrier *out)
8219 {
8220     if (!in) return;
8221
8222     out->sType = in->sType;
8223     out->pNext = NULL;
8224     out->srcAccessMask = in->srcAccessMask;
8225     out->dstAccessMask = in->dstAccessMask;
8226     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
8227     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
8228     out->buffer = in->buffer;
8229     out->offset = in->offset;
8230     out->size = in->size;
8231     if (in->pNext)
8232         FIXME("Unexpected pNext\n");
8233 }
8234
8235 static inline const VkBufferMemoryBarrier *convert_VkBufferMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier32 *in, uint32_t count)
8236 {
8237     VkBufferMemoryBarrier *out;
8238     unsigned int i;
8239
8240     if (!in || !count) return NULL;
8241
8242     out = conversion_context_alloc(ctx, count * sizeof(*out));
8243     for (i = 0; i < count; i++)
8244     {
8245         convert_VkBufferMemoryBarrier_win32_to_host(&in[i], &out[i]);
8246     }
8247
8248     return out;
8249 }
8250
8251 static inline void convert_VkImageMemoryBarrier_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier32 *in, VkImageMemoryBarrier *out)
8252 {
8253     const VkBaseInStructure32 *in_header;
8254     VkBaseOutStructure *out_header = (void *)out;
8255
8256     if (!in) return;
8257
8258     out->sType = in->sType;
8259     out->pNext = NULL;
8260     out->srcAccessMask = in->srcAccessMask;
8261     out->dstAccessMask = in->dstAccessMask;
8262     out->oldLayout = in->oldLayout;
8263     out->newLayout = in->newLayout;
8264     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
8265     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
8266     out->image = in->image;
8267     out->subresourceRange = in->subresourceRange;
8268
8269     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8270     {
8271         switch (in_header->sType)
8272         {
8273         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
8274         {
8275             VkSampleLocationsInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8276             const VkSampleLocationsInfoEXT32 *in_ext = (const VkSampleLocationsInfoEXT32 *)in_header;
8277             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT;
8278             out_ext->pNext = NULL;
8279             out_ext->sampleLocationsPerPixel = in_ext->sampleLocationsPerPixel;
8280             out_ext->sampleLocationGridSize = in_ext->sampleLocationGridSize;
8281             out_ext->sampleLocationsCount = in_ext->sampleLocationsCount;
8282             out_ext->pSampleLocations = (const VkSampleLocationEXT *)UlongToPtr(in_ext->pSampleLocations);
8283             out_header->pNext = (void *)out_ext;
8284             out_header = (void *)out_ext;
8285             break;
8286         }
8287         default:
8288             FIXME("Unhandled sType %u.\n", in_header->sType);
8289             break;
8290         }
8291     }
8292 }
8293
8294 static inline const VkImageMemoryBarrier *convert_VkImageMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier32 *in, uint32_t count)
8295 {
8296     VkImageMemoryBarrier *out;
8297     unsigned int i;
8298
8299     if (!in || !count) return NULL;
8300
8301     out = conversion_context_alloc(ctx, count * sizeof(*out));
8302     for (i = 0; i < count; i++)
8303     {
8304         convert_VkImageMemoryBarrier_win32_to_host(ctx, &in[i], &out[i]);
8305     }
8306
8307     return out;
8308 }
8309
8310 static inline void convert_VkMemoryBarrier2_win32_to_host(const VkMemoryBarrier232 *in, VkMemoryBarrier2 *out)
8311 {
8312     if (!in) return;
8313
8314     out->sType = in->sType;
8315     out->pNext = NULL;
8316     out->srcStageMask = in->srcStageMask;
8317     out->srcAccessMask = in->srcAccessMask;
8318     out->dstStageMask = in->dstStageMask;
8319     out->dstAccessMask = in->dstAccessMask;
8320     if (in->pNext)
8321         FIXME("Unexpected pNext\n");
8322 }
8323
8324 static inline const VkMemoryBarrier2 *convert_VkMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkMemoryBarrier232 *in, uint32_t count)
8325 {
8326     VkMemoryBarrier2 *out;
8327     unsigned int i;
8328
8329     if (!in || !count) return NULL;
8330
8331     out = conversion_context_alloc(ctx, count * sizeof(*out));
8332     for (i = 0; i < count; i++)
8333     {
8334         convert_VkMemoryBarrier2_win32_to_host(&in[i], &out[i]);
8335     }
8336
8337     return out;
8338 }
8339
8340 static inline void convert_VkBufferMemoryBarrier2_win32_to_host(const VkBufferMemoryBarrier232 *in, VkBufferMemoryBarrier2 *out)
8341 {
8342     if (!in) return;
8343
8344     out->sType = in->sType;
8345     out->pNext = NULL;
8346     out->srcStageMask = in->srcStageMask;
8347     out->srcAccessMask = in->srcAccessMask;
8348     out->dstStageMask = in->dstStageMask;
8349     out->dstAccessMask = in->dstAccessMask;
8350     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
8351     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
8352     out->buffer = in->buffer;
8353     out->offset = in->offset;
8354     out->size = in->size;
8355     if (in->pNext)
8356         FIXME("Unexpected pNext\n");
8357 }
8358
8359 static inline const VkBufferMemoryBarrier2 *convert_VkBufferMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier232 *in, uint32_t count)
8360 {
8361     VkBufferMemoryBarrier2 *out;
8362     unsigned int i;
8363
8364     if (!in || !count) return NULL;
8365
8366     out = conversion_context_alloc(ctx, count * sizeof(*out));
8367     for (i = 0; i < count; i++)
8368     {
8369         convert_VkBufferMemoryBarrier2_win32_to_host(&in[i], &out[i]);
8370     }
8371
8372     return out;
8373 }
8374
8375 static inline void convert_VkImageMemoryBarrier2_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier232 *in, VkImageMemoryBarrier2 *out)
8376 {
8377     const VkBaseInStructure32 *in_header;
8378     VkBaseOutStructure *out_header = (void *)out;
8379
8380     if (!in) return;
8381
8382     out->sType = in->sType;
8383     out->pNext = NULL;
8384     out->srcStageMask = in->srcStageMask;
8385     out->srcAccessMask = in->srcAccessMask;
8386     out->dstStageMask = in->dstStageMask;
8387     out->dstAccessMask = in->dstAccessMask;
8388     out->oldLayout = in->oldLayout;
8389     out->newLayout = in->newLayout;
8390     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
8391     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
8392     out->image = in->image;
8393     out->subresourceRange = in->subresourceRange;
8394
8395     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8396     {
8397         switch (in_header->sType)
8398         {
8399         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
8400         {
8401             VkSampleLocationsInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8402             const VkSampleLocationsInfoEXT32 *in_ext = (const VkSampleLocationsInfoEXT32 *)in_header;
8403             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT;
8404             out_ext->pNext = NULL;
8405             out_ext->sampleLocationsPerPixel = in_ext->sampleLocationsPerPixel;
8406             out_ext->sampleLocationGridSize = in_ext->sampleLocationGridSize;
8407             out_ext->sampleLocationsCount = in_ext->sampleLocationsCount;
8408             out_ext->pSampleLocations = (const VkSampleLocationEXT *)UlongToPtr(in_ext->pSampleLocations);
8409             out_header->pNext = (void *)out_ext;
8410             out_header = (void *)out_ext;
8411             break;
8412         }
8413         default:
8414             FIXME("Unhandled sType %u.\n", in_header->sType);
8415             break;
8416         }
8417     }
8418 }
8419
8420 static inline const VkImageMemoryBarrier2 *convert_VkImageMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier232 *in, uint32_t count)
8421 {
8422     VkImageMemoryBarrier2 *out;
8423     unsigned int i;
8424
8425     if (!in || !count) return NULL;
8426
8427     out = conversion_context_alloc(ctx, count * sizeof(*out));
8428     for (i = 0; i < count; i++)
8429     {
8430         convert_VkImageMemoryBarrier2_win32_to_host(ctx, &in[i], &out[i]);
8431     }
8432
8433     return out;
8434 }
8435
8436 static inline void convert_VkDependencyInfo_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, VkDependencyInfo *out)
8437 {
8438     if (!in) return;
8439
8440     out->sType = in->sType;
8441     out->pNext = NULL;
8442     out->dependencyFlags = in->dependencyFlags;
8443     out->memoryBarrierCount = in->memoryBarrierCount;
8444     out->pMemoryBarriers = convert_VkMemoryBarrier2_array_win32_to_host(ctx, (const VkMemoryBarrier232 *)UlongToPtr(in->pMemoryBarriers), in->memoryBarrierCount);
8445     out->bufferMemoryBarrierCount = in->bufferMemoryBarrierCount;
8446     out->pBufferMemoryBarriers = convert_VkBufferMemoryBarrier2_array_win32_to_host(ctx, (const VkBufferMemoryBarrier232 *)UlongToPtr(in->pBufferMemoryBarriers), in->bufferMemoryBarrierCount);
8447     out->imageMemoryBarrierCount = in->imageMemoryBarrierCount;
8448     out->pImageMemoryBarriers = convert_VkImageMemoryBarrier2_array_win32_to_host(ctx, (const VkImageMemoryBarrier232 *)UlongToPtr(in->pImageMemoryBarriers), in->imageMemoryBarrierCount);
8449     if (in->pNext)
8450         FIXME("Unexpected pNext\n");
8451 }
8452
8453 static inline void convert_VkDescriptorImageInfo_win32_to_host(const VkDescriptorImageInfo32 *in, VkDescriptorImageInfo *out)
8454 {
8455     if (!in) return;
8456
8457     out->sampler = in->sampler;
8458     out->imageView = in->imageView;
8459     out->imageLayout = in->imageLayout;
8460 }
8461
8462 static inline const VkDescriptorImageInfo *convert_VkDescriptorImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorImageInfo32 *in, uint32_t count)
8463 {
8464     VkDescriptorImageInfo *out;
8465     unsigned int i;
8466
8467     if (!in || !count) return NULL;
8468
8469     out = conversion_context_alloc(ctx, count * sizeof(*out));
8470     for (i = 0; i < count; i++)
8471     {
8472         convert_VkDescriptorImageInfo_win32_to_host(&in[i], &out[i]);
8473     }
8474
8475     return out;
8476 }
8477
8478 static inline void convert_VkDescriptorBufferInfo_win32_to_host(const VkDescriptorBufferInfo32 *in, VkDescriptorBufferInfo *out)
8479 {
8480     if (!in) return;
8481
8482     out->buffer = in->buffer;
8483     out->offset = in->offset;
8484     out->range = in->range;
8485 }
8486
8487 static inline const VkDescriptorBufferInfo *convert_VkDescriptorBufferInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferInfo32 *in, uint32_t count)
8488 {
8489     VkDescriptorBufferInfo *out;
8490     unsigned int i;
8491
8492     if (!in || !count) return NULL;
8493
8494     out = conversion_context_alloc(ctx, count * sizeof(*out));
8495     for (i = 0; i < count; i++)
8496     {
8497         convert_VkDescriptorBufferInfo_win32_to_host(&in[i], &out[i]);
8498     }
8499
8500     return out;
8501 }
8502
8503 static inline void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, VkWriteDescriptorSet *out)
8504 {
8505     const VkBaseInStructure32 *in_header;
8506     VkBaseOutStructure *out_header = (void *)out;
8507
8508     if (!in) return;
8509
8510     out->sType = in->sType;
8511     out->pNext = NULL;
8512     out->dstSet = in->dstSet;
8513     out->dstBinding = in->dstBinding;
8514     out->dstArrayElement = in->dstArrayElement;
8515     out->descriptorCount = in->descriptorCount;
8516     out->descriptorType = in->descriptorType;
8517     out->pImageInfo = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(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);
8518     out->pBufferInfo = convert_VkDescriptorBufferInfo_array_win32_to_host(ctx, (const VkDescriptorBufferInfo32 *)UlongToPtr(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);
8519     out->pTexelBufferView = (const VkBufferView *)UlongToPtr(in->pTexelBufferView);
8520
8521     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8522     {
8523         switch (in_header->sType)
8524         {
8525         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
8526         {
8527             VkWriteDescriptorSetInlineUniformBlock *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8528             const VkWriteDescriptorSetInlineUniformBlock32 *in_ext = (const VkWriteDescriptorSetInlineUniformBlock32 *)in_header;
8529             out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK;
8530             out_ext->pNext = NULL;
8531             out_ext->dataSize = in_ext->dataSize;
8532             out_ext->pData = (const void *)UlongToPtr(in_ext->pData);
8533             out_header->pNext = (void *)out_ext;
8534             out_header = (void *)out_ext;
8535             break;
8536         }
8537         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
8538         {
8539             VkWriteDescriptorSetAccelerationStructureKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8540             const VkWriteDescriptorSetAccelerationStructureKHR32 *in_ext = (const VkWriteDescriptorSetAccelerationStructureKHR32 *)in_header;
8541             out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR;
8542             out_ext->pNext = NULL;
8543             out_ext->accelerationStructureCount = in_ext->accelerationStructureCount;
8544             out_ext->pAccelerationStructures = (const VkAccelerationStructureKHR *)UlongToPtr(in_ext->pAccelerationStructures);
8545             out_header->pNext = (void *)out_ext;
8546             out_header = (void *)out_ext;
8547             break;
8548         }
8549         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
8550         {
8551             VkWriteDescriptorSetAccelerationStructureNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8552             const VkWriteDescriptorSetAccelerationStructureNV32 *in_ext = (const VkWriteDescriptorSetAccelerationStructureNV32 *)in_header;
8553             out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV;
8554             out_ext->pNext = NULL;
8555             out_ext->accelerationStructureCount = in_ext->accelerationStructureCount;
8556             out_ext->pAccelerationStructures = (const VkAccelerationStructureNV *)UlongToPtr(in_ext->pAccelerationStructures);
8557             out_header->pNext = (void *)out_ext;
8558             out_header = (void *)out_ext;
8559             break;
8560         }
8561         default:
8562             FIXME("Unhandled sType %u.\n", in_header->sType);
8563             break;
8564         }
8565     }
8566 }
8567
8568 static inline const VkWriteDescriptorSet *convert_VkWriteDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, uint32_t count)
8569 {
8570     VkWriteDescriptorSet *out;
8571     unsigned int i;
8572
8573     if (!in || !count) return NULL;
8574
8575     out = conversion_context_alloc(ctx, count * sizeof(*out));
8576     for (i = 0; i < count; i++)
8577     {
8578         convert_VkWriteDescriptorSet_win32_to_host(ctx, &in[i], &out[i]);
8579     }
8580
8581     return out;
8582 }
8583
8584 static inline void convert_VkImageResolve2_win32_to_host(const VkImageResolve232 *in, VkImageResolve2 *out)
8585 {
8586     if (!in) return;
8587
8588     out->sType = in->sType;
8589     out->pNext = NULL;
8590     out->srcSubresource = in->srcSubresource;
8591     out->srcOffset = in->srcOffset;
8592     out->dstSubresource = in->dstSubresource;
8593     out->dstOffset = in->dstOffset;
8594     out->extent = in->extent;
8595     if (in->pNext)
8596         FIXME("Unexpected pNext\n");
8597 }
8598
8599 static inline const VkImageResolve2 *convert_VkImageResolve2_array_win32_to_host(struct conversion_context *ctx, const VkImageResolve232 *in, uint32_t count)
8600 {
8601     VkImageResolve2 *out;
8602     unsigned int i;
8603
8604     if (!in || !count) return NULL;
8605
8606     out = conversion_context_alloc(ctx, count * sizeof(*out));
8607     for (i = 0; i < count; i++)
8608     {
8609         convert_VkImageResolve2_win32_to_host(&in[i], &out[i]);
8610     }
8611
8612     return out;
8613 }
8614
8615 static inline void convert_VkResolveImageInfo2_win32_to_host(struct conversion_context *ctx, const VkResolveImageInfo232 *in, VkResolveImageInfo2 *out)
8616 {
8617     if (!in) return;
8618
8619     out->sType = in->sType;
8620     out->pNext = NULL;
8621     out->srcImage = in->srcImage;
8622     out->srcImageLayout = in->srcImageLayout;
8623     out->dstImage = in->dstImage;
8624     out->dstImageLayout = in->dstImageLayout;
8625     out->regionCount = in->regionCount;
8626     out->pRegions = convert_VkImageResolve2_array_win32_to_host(ctx, (const VkImageResolve232 *)UlongToPtr(in->pRegions), in->regionCount);
8627     if (in->pNext)
8628         FIXME("Unexpected pNext\n");
8629 }
8630
8631 static inline void convert_VkCoarseSampleOrderCustomNV_win32_to_host(const VkCoarseSampleOrderCustomNV32 *in, VkCoarseSampleOrderCustomNV *out)
8632 {
8633     if (!in) return;
8634
8635     out->shadingRate = in->shadingRate;
8636     out->sampleCount = in->sampleCount;
8637     out->sampleLocationCount = in->sampleLocationCount;
8638     out->pSampleLocations = (const VkCoarseSampleLocationNV *)UlongToPtr(in->pSampleLocations);
8639 }
8640
8641 static inline const VkCoarseSampleOrderCustomNV *convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(struct conversion_context *ctx, const VkCoarseSampleOrderCustomNV32 *in, uint32_t count)
8642 {
8643     VkCoarseSampleOrderCustomNV *out;
8644     unsigned int i;
8645
8646     if (!in || !count) return NULL;
8647
8648     out = conversion_context_alloc(ctx, count * sizeof(*out));
8649     for (i = 0; i < count; i++)
8650     {
8651         convert_VkCoarseSampleOrderCustomNV_win32_to_host(&in[i], &out[i]);
8652     }
8653
8654     return out;
8655 }
8656
8657 static inline void convert_VkPerformanceMarkerInfoINTEL_win32_to_host(const VkPerformanceMarkerInfoINTEL32 *in, VkPerformanceMarkerInfoINTEL *out)
8658 {
8659     if (!in) return;
8660
8661     out->sType = in->sType;
8662     out->pNext = NULL;
8663     out->marker = in->marker;
8664     if (in->pNext)
8665         FIXME("Unexpected pNext\n");
8666 }
8667
8668 static inline void convert_VkPerformanceOverrideInfoINTEL_win32_to_host(const VkPerformanceOverrideInfoINTEL32 *in, VkPerformanceOverrideInfoINTEL *out)
8669 {
8670     if (!in) return;
8671
8672     out->sType = in->sType;
8673     out->pNext = NULL;
8674     out->type = in->type;
8675     out->enable = in->enable;
8676     out->parameter = in->parameter;
8677     if (in->pNext)
8678         FIXME("Unexpected pNext\n");
8679 }
8680
8681 static inline void convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host(const VkPerformanceStreamMarkerInfoINTEL32 *in, VkPerformanceStreamMarkerInfoINTEL *out)
8682 {
8683     if (!in) return;
8684
8685     out->sType = in->sType;
8686     out->pNext = NULL;
8687     out->marker = in->marker;
8688     if (in->pNext)
8689         FIXME("Unexpected pNext\n");
8690 }
8691
8692 static inline void convert_VkVertexInputBindingDescription2EXT_win32_to_host(const VkVertexInputBindingDescription2EXT32 *in, VkVertexInputBindingDescription2EXT *out)
8693 {
8694     if (!in) return;
8695
8696     out->sType = in->sType;
8697     out->pNext = NULL;
8698     out->binding = in->binding;
8699     out->stride = in->stride;
8700     out->inputRate = in->inputRate;
8701     out->divisor = in->divisor;
8702     if (in->pNext)
8703         FIXME("Unexpected pNext\n");
8704 }
8705
8706 static inline const VkVertexInputBindingDescription2EXT *convert_VkVertexInputBindingDescription2EXT_array_win32_to_host(struct conversion_context *ctx, const VkVertexInputBindingDescription2EXT32 *in, uint32_t count)
8707 {
8708     VkVertexInputBindingDescription2EXT *out;
8709     unsigned int i;
8710
8711     if (!in || !count) return NULL;
8712
8713     out = conversion_context_alloc(ctx, count * sizeof(*out));
8714     for (i = 0; i < count; i++)
8715     {
8716         convert_VkVertexInputBindingDescription2EXT_win32_to_host(&in[i], &out[i]);
8717     }
8718
8719     return out;
8720 }
8721
8722 static inline void convert_VkVertexInputAttributeDescription2EXT_win32_to_host(const VkVertexInputAttributeDescription2EXT32 *in, VkVertexInputAttributeDescription2EXT *out)
8723 {
8724     if (!in) return;
8725
8726     out->sType = in->sType;
8727     out->pNext = NULL;
8728     out->location = in->location;
8729     out->binding = in->binding;
8730     out->format = in->format;
8731     out->offset = in->offset;
8732     if (in->pNext)
8733         FIXME("Unexpected pNext\n");
8734 }
8735
8736 static inline const VkVertexInputAttributeDescription2EXT *convert_VkVertexInputAttributeDescription2EXT_array_win32_to_host(struct conversion_context *ctx, const VkVertexInputAttributeDescription2EXT32 *in, uint32_t count)
8737 {
8738     VkVertexInputAttributeDescription2EXT *out;
8739     unsigned int i;
8740
8741     if (!in || !count) return NULL;
8742
8743     out = conversion_context_alloc(ctx, count * sizeof(*out));
8744     for (i = 0; i < count; i++)
8745     {
8746         convert_VkVertexInputAttributeDescription2EXT_win32_to_host(&in[i], &out[i]);
8747     }
8748
8749     return out;
8750 }
8751
8752 static inline void convert_VkShadingRatePaletteNV_win32_to_host(const VkShadingRatePaletteNV32 *in, VkShadingRatePaletteNV *out)
8753 {
8754     if (!in) return;
8755
8756     out->shadingRatePaletteEntryCount = in->shadingRatePaletteEntryCount;
8757     out->pShadingRatePaletteEntries = (const VkShadingRatePaletteEntryNV *)UlongToPtr(in->pShadingRatePaletteEntries);
8758 }
8759
8760 static inline const VkShadingRatePaletteNV *convert_VkShadingRatePaletteNV_array_win32_to_host(struct conversion_context *ctx, const VkShadingRatePaletteNV32 *in, uint32_t count)
8761 {
8762     VkShadingRatePaletteNV *out;
8763     unsigned int i;
8764
8765     if (!in || !count) return NULL;
8766
8767     out = conversion_context_alloc(ctx, count * sizeof(*out));
8768     for (i = 0; i < count; i++)
8769     {
8770         convert_VkShadingRatePaletteNV_win32_to_host(&in[i], &out[i]);
8771     }
8772
8773     return out;
8774 }
8775
8776 static inline void convert_VkStridedDeviceAddressRegionKHR_win32_to_host(const VkStridedDeviceAddressRegionKHR32 *in, VkStridedDeviceAddressRegionKHR *out)
8777 {
8778     if (!in) return;
8779
8780     out->deviceAddress = in->deviceAddress;
8781     out->stride = in->stride;
8782     out->size = in->size;
8783 }
8784
8785 static inline const VkDependencyInfo *convert_VkDependencyInfo_array_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, uint32_t count)
8786 {
8787     VkDependencyInfo *out;
8788     unsigned int i;
8789
8790     if (!in || !count) return NULL;
8791
8792     out = conversion_context_alloc(ctx, count * sizeof(*out));
8793     for (i = 0; i < count; i++)
8794     {
8795         convert_VkDependencyInfo_win32_to_host(ctx, &in[i], &out[i]);
8796     }
8797
8798     return out;
8799 }
8800
8801 static inline void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoKHR32 *in, VkAccelerationStructureCreateInfoKHR *out)
8802 {
8803     const VkBaseInStructure32 *in_header;
8804     VkBaseOutStructure *out_header = (void *)out;
8805
8806     if (!in) return;
8807
8808     out->sType = in->sType;
8809     out->pNext = NULL;
8810     out->createFlags = in->createFlags;
8811     out->buffer = in->buffer;
8812     out->offset = in->offset;
8813     out->size = in->size;
8814     out->type = in->type;
8815     out->deviceAddress = in->deviceAddress;
8816
8817     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8818     {
8819         switch (in_header->sType)
8820         {
8821         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
8822         {
8823             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8824             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
8825             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
8826             out_ext->pNext = NULL;
8827             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
8828             out_header->pNext = (void *)out_ext;
8829             out_header = (void *)out_ext;
8830             break;
8831         }
8832         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
8833         {
8834             VkAccelerationStructureMotionInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8835             const VkAccelerationStructureMotionInfoNV32 *in_ext = (const VkAccelerationStructureMotionInfoNV32 *)in_header;
8836             out_ext->sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV;
8837             out_ext->pNext = NULL;
8838             out_ext->maxInstances = in_ext->maxInstances;
8839             out_ext->flags = in_ext->flags;
8840             out_header->pNext = (void *)out_ext;
8841             out_header = (void *)out_ext;
8842             break;
8843         }
8844         default:
8845             FIXME("Unhandled sType %u.\n", in_header->sType);
8846             break;
8847         }
8848     }
8849 }
8850
8851 static inline void convert_VkAccelerationStructureCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoNV32 *in, VkAccelerationStructureCreateInfoNV *out)
8852 {
8853     const VkBaseInStructure32 *in_header;
8854     VkBaseOutStructure *out_header = (void *)out;
8855
8856     if (!in) return;
8857
8858     out->sType = in->sType;
8859     out->pNext = NULL;
8860     out->compactedSize = in->compactedSize;
8861     convert_VkAccelerationStructureInfoNV_win32_to_host(ctx, &in->info, &out->info);
8862
8863     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8864     {
8865         switch (in_header->sType)
8866         {
8867         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
8868         {
8869             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8870             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
8871             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
8872             out_ext->pNext = NULL;
8873             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
8874             out_header->pNext = (void *)out_ext;
8875             out_header = (void *)out_ext;
8876             break;
8877         }
8878         default:
8879             FIXME("Unhandled sType %u.\n", in_header->sType);
8880             break;
8881         }
8882     }
8883 }
8884
8885 static inline void convert_VkBufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, VkBufferCreateInfo *out)
8886 {
8887     const VkBaseInStructure32 *in_header;
8888     VkBaseOutStructure *out_header = (void *)out;
8889
8890     if (!in) return;
8891
8892     out->sType = in->sType;
8893     out->pNext = NULL;
8894     out->flags = in->flags;
8895     out->size = in->size;
8896     out->usage = in->usage;
8897     out->sharingMode = in->sharingMode;
8898     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
8899     out->pQueueFamilyIndices = (const uint32_t *)UlongToPtr(in->pQueueFamilyIndices);
8900
8901     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8902     {
8903         switch (in_header->sType)
8904         {
8905         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
8906         {
8907             VkDedicatedAllocationBufferCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8908             const VkDedicatedAllocationBufferCreateInfoNV32 *in_ext = (const VkDedicatedAllocationBufferCreateInfoNV32 *)in_header;
8909             out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV;
8910             out_ext->pNext = NULL;
8911             out_ext->dedicatedAllocation = in_ext->dedicatedAllocation;
8912             out_header->pNext = (void *)out_ext;
8913             out_header = (void *)out_ext;
8914             break;
8915         }
8916         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
8917         {
8918             VkExternalMemoryBufferCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8919             const VkExternalMemoryBufferCreateInfo32 *in_ext = (const VkExternalMemoryBufferCreateInfo32 *)in_header;
8920             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
8921             out_ext->pNext = NULL;
8922             out_ext->handleTypes = in_ext->handleTypes;
8923             out_header->pNext = (void *)out_ext;
8924             out_header = (void *)out_ext;
8925             break;
8926         }
8927         case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
8928         {
8929             VkBufferOpaqueCaptureAddressCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8930             const VkBufferOpaqueCaptureAddressCreateInfo32 *in_ext = (const VkBufferOpaqueCaptureAddressCreateInfo32 *)in_header;
8931             out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
8932             out_ext->pNext = NULL;
8933             out_ext->opaqueCaptureAddress = in_ext->opaqueCaptureAddress;
8934             out_header->pNext = (void *)out_ext;
8935             out_header = (void *)out_ext;
8936             break;
8937         }
8938         case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
8939         {
8940             VkBufferDeviceAddressCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8941             const VkBufferDeviceAddressCreateInfoEXT32 *in_ext = (const VkBufferDeviceAddressCreateInfoEXT32 *)in_header;
8942             out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT;
8943             out_ext->pNext = NULL;
8944             out_ext->deviceAddress = in_ext->deviceAddress;
8945             out_header->pNext = (void *)out_ext;
8946             out_header = (void *)out_ext;
8947             break;
8948         }
8949         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
8950         {
8951             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8952             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
8953             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
8954             out_ext->pNext = NULL;
8955             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
8956             out_header->pNext = (void *)out_ext;
8957             out_header = (void *)out_ext;
8958             break;
8959         }
8960         default:
8961             FIXME("Unhandled sType %u.\n", in_header->sType);
8962             break;
8963         }
8964     }
8965 }
8966
8967 static inline void convert_VkBufferViewCreateInfo_win32_to_host(const VkBufferViewCreateInfo32 *in, VkBufferViewCreateInfo *out)
8968 {
8969     if (!in) return;
8970
8971     out->sType = in->sType;
8972     out->pNext = NULL;
8973     out->flags = in->flags;
8974     out->buffer = in->buffer;
8975     out->format = in->format;
8976     out->offset = in->offset;
8977     out->range = in->range;
8978     if (in->pNext)
8979         FIXME("Unexpected pNext\n");
8980 }
8981
8982 static inline void convert_VkCommandPoolCreateInfo_win32_to_host(const VkCommandPoolCreateInfo32 *in, VkCommandPoolCreateInfo *out)
8983 {
8984     if (!in) return;
8985
8986     out->sType = in->sType;
8987     out->pNext = NULL;
8988     out->flags = in->flags;
8989     out->queueFamilyIndex = in->queueFamilyIndex;
8990     if (in->pNext)
8991         FIXME("Unexpected pNext\n");
8992 }
8993
8994 static inline void convert_VkPipelineCreationFeedback_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out)
8995 {
8996     if (!in) return;
8997
8998     out->flags = in->flags;
8999     out->duration = in->duration;
9000 }
9001
9002 static inline VkPipelineCreationFeedback *convert_VkPipelineCreationFeedback_array_win32_to_host(struct conversion_context *ctx, const VkPipelineCreationFeedback32 *in, uint32_t count)
9003 {
9004     VkPipelineCreationFeedback *out;
9005     if (!in || !count) return NULL;
9006
9007     out = conversion_context_alloc(ctx, count * sizeof(*out));
9008
9009     return out;
9010 }
9011
9012 static inline void convert_VkPipelineCreationFeedback_array_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out, uint32_t count)
9013 {
9014     unsigned int i;
9015
9016     if (!in) return;
9017
9018     for (i = 0; i < count; i++)
9019     {
9020         convert_VkPipelineCreationFeedback_host_to_win32(&in[i], &out[i]);
9021     }
9022 }
9023
9024 static inline void convert_VkSpecializationMapEntry_win32_to_host(const VkSpecializationMapEntry32 *in, VkSpecializationMapEntry *out)
9025 {
9026     if (!in) return;
9027
9028     out->constantID = in->constantID;
9029     out->offset = in->offset;
9030     out->size = in->size;
9031 }
9032
9033 static inline const VkSpecializationMapEntry *convert_VkSpecializationMapEntry_array_win32_to_host(struct conversion_context *ctx, const VkSpecializationMapEntry32 *in, uint32_t count)
9034 {
9035     VkSpecializationMapEntry *out;
9036     unsigned int i;
9037
9038     if (!in || !count) return NULL;
9039
9040     out = conversion_context_alloc(ctx, count * sizeof(*out));
9041     for (i = 0; i < count; i++)
9042     {
9043         convert_VkSpecializationMapEntry_win32_to_host(&in[i], &out[i]);
9044     }
9045
9046     return out;
9047 }
9048
9049 static inline void convert_VkSpecializationInfo_win32_to_host(struct conversion_context *ctx, const VkSpecializationInfo32 *in, VkSpecializationInfo *out)
9050 {
9051     if (!in) return;
9052
9053     out->mapEntryCount = in->mapEntryCount;
9054     out->pMapEntries = convert_VkSpecializationMapEntry_array_win32_to_host(ctx, (const VkSpecializationMapEntry32 *)UlongToPtr(in->pMapEntries), in->mapEntryCount);
9055     out->dataSize = in->dataSize;
9056     out->pData = (const void *)UlongToPtr(in->pData);
9057 }
9058
9059 static inline const VkSpecializationInfo *convert_VkSpecializationInfo_array_win32_to_host(struct conversion_context *ctx, const VkSpecializationInfo32 *in, uint32_t count)
9060 {
9061     VkSpecializationInfo *out;
9062     unsigned int i;
9063
9064     if (!in || !count) return NULL;
9065
9066     out = conversion_context_alloc(ctx, count * sizeof(*out));
9067     for (i = 0; i < count; i++)
9068     {
9069         convert_VkSpecializationInfo_win32_to_host(ctx, &in[i], &out[i]);
9070     }
9071
9072     return out;
9073 }
9074
9075 #ifdef _WIN64
9076 static inline void convert_VkPipelineShaderStageCreateInfo_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, VkPipelineShaderStageCreateInfo *out)
9077 {
9078     const VkBaseInStructure *in_header;
9079     VkBaseOutStructure *out_header = (void *)out;
9080
9081     if (!in) return;
9082
9083     out->sType = in->sType;
9084     out->pNext = NULL;
9085     out->flags = in->flags;
9086     out->stage = in->stage;
9087     out->module = in->module;
9088     out->pName = in->pName;
9089     out->pSpecializationInfo = in->pSpecializationInfo;
9090
9091     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
9092     {
9093         switch (in_header->sType)
9094         {
9095         case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
9096         {
9097             VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9098             const VkShaderModuleCreateInfo *in_ext = (const VkShaderModuleCreateInfo *)in_header;
9099             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
9100             out_ext->pNext = NULL;
9101             out_ext->flags = in_ext->flags;
9102             out_ext->codeSize = in_ext->codeSize;
9103             out_ext->pCode = in_ext->pCode;
9104             out_header->pNext = (void *)out_ext;
9105             out_header = (void *)out_ext;
9106             break;
9107         }
9108         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
9109         {
9110             VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9111             const VkShaderModuleValidationCacheCreateInfoEXT *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT *)in_header;
9112             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
9113             out_ext->pNext = NULL;
9114             out_ext->validationCache = in_ext->validationCache;
9115             out_header->pNext = (void *)out_ext;
9116             out_header = (void *)out_ext;
9117             break;
9118         }
9119         case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
9120         {
9121             VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9122             const VkDebugUtilsObjectNameInfoEXT *in_ext = (const VkDebugUtilsObjectNameInfoEXT *)in_header;
9123             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
9124             out_ext->pNext = NULL;
9125             out_ext->objectType = in_ext->objectType;
9126             out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle);
9127             out_ext->pObjectName = in_ext->pObjectName;
9128             out_header->pNext = (void *)out_ext;
9129             out_header = (void *)out_ext;
9130             break;
9131         }
9132         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
9133         {
9134             VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9135             const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *in_ext = (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)in_header;
9136             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
9137             out_ext->pNext = NULL;
9138             out_ext->requiredSubgroupSize = in_ext->requiredSubgroupSize;
9139             out_header->pNext = (void *)out_ext;
9140             out_header = (void *)out_ext;
9141             break;
9142         }
9143         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
9144         {
9145             VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9146             const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *)in_header;
9147             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
9148             out_ext->pNext = NULL;
9149             out_ext->identifierSize = in_ext->identifierSize;
9150             out_ext->pIdentifier = in_ext->pIdentifier;
9151             out_header->pNext = (void *)out_ext;
9152             out_header = (void *)out_ext;
9153             break;
9154         }
9155         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
9156         {
9157             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9158             const VkPipelineRobustnessCreateInfoEXT *in_ext = (const VkPipelineRobustnessCreateInfoEXT *)in_header;
9159             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
9160             out_ext->pNext = NULL;
9161             out_ext->storageBuffers = in_ext->storageBuffers;
9162             out_ext->uniformBuffers = in_ext->uniformBuffers;
9163             out_ext->vertexInputs = in_ext->vertexInputs;
9164             out_ext->images = in_ext->images;
9165             out_header->pNext = (void *)out_ext;
9166             out_header = (void *)out_ext;
9167             break;
9168         }
9169         default:
9170             FIXME("Unhandled sType %u.\n", in_header->sType);
9171             break;
9172         }
9173     }
9174 }
9175 #endif /* _WIN64 */
9176
9177 static inline void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, VkPipelineShaderStageCreateInfo *out)
9178 {
9179     const VkBaseInStructure32 *in_header;
9180     VkBaseOutStructure *out_header = (void *)out;
9181
9182     if (!in) return;
9183
9184     out->sType = in->sType;
9185     out->pNext = NULL;
9186     out->flags = in->flags;
9187     out->stage = in->stage;
9188     out->module = in->module;
9189     out->pName = (const char *)UlongToPtr(in->pName);
9190     out->pSpecializationInfo = convert_VkSpecializationInfo_array_win32_to_host(ctx, (const VkSpecializationInfo32 *)UlongToPtr(in->pSpecializationInfo), 1);
9191
9192     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9193     {
9194         switch (in_header->sType)
9195         {
9196         case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
9197         {
9198             VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9199             const VkShaderModuleCreateInfo32 *in_ext = (const VkShaderModuleCreateInfo32 *)in_header;
9200             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
9201             out_ext->pNext = NULL;
9202             out_ext->flags = in_ext->flags;
9203             out_ext->codeSize = in_ext->codeSize;
9204             out_ext->pCode = (const uint32_t *)UlongToPtr(in_ext->pCode);
9205             out_header->pNext = (void *)out_ext;
9206             out_header = (void *)out_ext;
9207             break;
9208         }
9209         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
9210         {
9211             VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9212             const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header;
9213             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
9214             out_ext->pNext = NULL;
9215             out_ext->validationCache = in_ext->validationCache;
9216             out_header->pNext = (void *)out_ext;
9217             out_header = (void *)out_ext;
9218             break;
9219         }
9220         case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
9221         {
9222             VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9223             const VkDebugUtilsObjectNameInfoEXT32 *in_ext = (const VkDebugUtilsObjectNameInfoEXT32 *)in_header;
9224             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
9225             out_ext->pNext = NULL;
9226             out_ext->objectType = in_ext->objectType;
9227             out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle);
9228             out_ext->pObjectName = (const char *)UlongToPtr(in_ext->pObjectName);
9229             out_header->pNext = (void *)out_ext;
9230             out_header = (void *)out_ext;
9231             break;
9232         }
9233         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
9234         {
9235             VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9236             const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *in_ext = (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *)in_header;
9237             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
9238             out_ext->pNext = NULL;
9239             out_ext->requiredSubgroupSize = in_ext->requiredSubgroupSize;
9240             out_header->pNext = (void *)out_ext;
9241             out_header = (void *)out_ext;
9242             break;
9243         }
9244         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
9245         {
9246             VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9247             const VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 *)in_header;
9248             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
9249             out_ext->pNext = NULL;
9250             out_ext->identifierSize = in_ext->identifierSize;
9251             out_ext->pIdentifier = (const uint8_t *)UlongToPtr(in_ext->pIdentifier);
9252             out_header->pNext = (void *)out_ext;
9253             out_header = (void *)out_ext;
9254             break;
9255         }
9256         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
9257         {
9258             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9259             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
9260             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
9261             out_ext->pNext = NULL;
9262             out_ext->storageBuffers = in_ext->storageBuffers;
9263             out_ext->uniformBuffers = in_ext->uniformBuffers;
9264             out_ext->vertexInputs = in_ext->vertexInputs;
9265             out_ext->images = in_ext->images;
9266             out_header->pNext = (void *)out_ext;
9267             out_header = (void *)out_ext;
9268             break;
9269         }
9270         default:
9271             FIXME("Unhandled sType %u.\n", in_header->sType);
9272             break;
9273         }
9274     }
9275 }
9276
9277 #ifdef _WIN64
9278 static inline void convert_VkComputePipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, VkComputePipelineCreateInfo *out)
9279 {
9280     if (!in) return;
9281
9282     out->sType = in->sType;
9283     out->pNext = in->pNext;
9284     out->flags = in->flags;
9285     convert_VkPipelineShaderStageCreateInfo_win64_to_host(ctx, &in->stage, &out->stage);
9286     out->layout = in->layout;
9287     out->basePipelineHandle = in->basePipelineHandle;
9288     out->basePipelineIndex = in->basePipelineIndex;
9289 }
9290 #endif /* _WIN64 */
9291
9292 static inline void convert_VkComputePipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, VkComputePipelineCreateInfo *out)
9293 {
9294     const VkBaseInStructure32 *in_header;
9295     VkBaseOutStructure *out_header = (void *)out;
9296
9297     if (!in) return;
9298
9299     out->sType = in->sType;
9300     out->pNext = NULL;
9301     out->flags = in->flags;
9302     convert_VkPipelineShaderStageCreateInfo_win32_to_host(ctx, &in->stage, &out->stage);
9303     out->layout = in->layout;
9304     out->basePipelineHandle = in->basePipelineHandle;
9305     out->basePipelineIndex = in->basePipelineIndex;
9306
9307     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9308     {
9309         switch (in_header->sType)
9310         {
9311         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
9312         {
9313             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9314             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
9315             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
9316             out_ext->pNext = NULL;
9317             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
9318             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
9319             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
9320             out_header->pNext = (void *)out_ext;
9321             out_header = (void *)out_ext;
9322             break;
9323         }
9324         case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
9325         {
9326             VkSubpassShadingPipelineCreateInfoHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9327             const VkSubpassShadingPipelineCreateInfoHUAWEI32 *in_ext = (const VkSubpassShadingPipelineCreateInfoHUAWEI32 *)in_header;
9328             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI;
9329             out_ext->pNext = NULL;
9330             out_ext->renderPass = in_ext->renderPass;
9331             out_ext->subpass = in_ext->subpass;
9332             out_header->pNext = (void *)out_ext;
9333             out_header = (void *)out_ext;
9334             break;
9335         }
9336         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
9337         {
9338             VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9339             const VkPipelineCompilerControlCreateInfoAMD32 *in_ext = (const VkPipelineCompilerControlCreateInfoAMD32 *)in_header;
9340             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
9341             out_ext->pNext = NULL;
9342             out_ext->compilerControlFlags = in_ext->compilerControlFlags;
9343             out_header->pNext = (void *)out_ext;
9344             out_header = (void *)out_ext;
9345             break;
9346         }
9347         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
9348         {
9349             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9350             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
9351             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
9352             out_ext->pNext = NULL;
9353             out_ext->storageBuffers = in_ext->storageBuffers;
9354             out_ext->uniformBuffers = in_ext->uniformBuffers;
9355             out_ext->vertexInputs = in_ext->vertexInputs;
9356             out_ext->images = in_ext->images;
9357             out_header->pNext = (void *)out_ext;
9358             out_header = (void *)out_ext;
9359             break;
9360         }
9361         default:
9362             FIXME("Unhandled sType %u.\n", in_header->sType);
9363             break;
9364         }
9365     }
9366 }
9367
9368 static inline void convert_VkComputePipelineCreateInfo_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out)
9369 {
9370     const VkBaseInStructure *in_header;
9371     VkBaseOutStructure32 *out_header = (void *)out;
9372
9373     if (!in) return;
9374
9375
9376     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
9377     {
9378         switch (in_header->sType)
9379         {
9380         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
9381         {
9382             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
9383             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
9384             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
9385             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
9386             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
9387             out_header = (void *)out_ext;
9388             break;
9389         }
9390         default:
9391             break;
9392         }
9393     }
9394 }
9395
9396 #ifdef _WIN64
9397 static inline const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, uint32_t count)
9398 {
9399     VkComputePipelineCreateInfo *out;
9400     unsigned int i;
9401
9402     if (!in || !count) return NULL;
9403
9404     out = conversion_context_alloc(ctx, count * sizeof(*out));
9405     for (i = 0; i < count; i++)
9406     {
9407         convert_VkComputePipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
9408     }
9409
9410     return out;
9411 }
9412 #endif /* _WIN64 */
9413
9414 static inline const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, uint32_t count)
9415 {
9416     VkComputePipelineCreateInfo *out;
9417     unsigned int i;
9418
9419     if (!in || !count) return NULL;
9420
9421     out = conversion_context_alloc(ctx, count * sizeof(*out));
9422     for (i = 0; i < count; i++)
9423     {
9424         convert_VkComputePipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
9425     }
9426
9427     return out;
9428 }
9429
9430 static inline void convert_VkComputePipelineCreateInfo_array_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out, uint32_t count)
9431 {
9432     unsigned int i;
9433
9434     if (!in) return;
9435
9436     for (i = 0; i < count; i++)
9437     {
9438         convert_VkComputePipelineCreateInfo_host_to_win32(&in[i], &out[i]);
9439     }
9440 }
9441
9442 static inline void convert_VkCuFunctionCreateInfoNVX_win32_to_host(const VkCuFunctionCreateInfoNVX32 *in, VkCuFunctionCreateInfoNVX *out)
9443 {
9444     if (!in) return;
9445
9446     out->sType = in->sType;
9447     out->pNext = NULL;
9448     out->module = in->module;
9449     out->pName = (const char *)UlongToPtr(in->pName);
9450     if (in->pNext)
9451         FIXME("Unexpected pNext\n");
9452 }
9453
9454 static inline void convert_VkCuModuleCreateInfoNVX_win32_to_host(const VkCuModuleCreateInfoNVX32 *in, VkCuModuleCreateInfoNVX *out)
9455 {
9456     if (!in) return;
9457
9458     out->sType = in->sType;
9459     out->pNext = NULL;
9460     out->dataSize = in->dataSize;
9461     out->pData = (const void *)UlongToPtr(in->pData);
9462     if (in->pNext)
9463         FIXME("Unexpected pNext\n");
9464 }
9465
9466 static inline void convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host(const VkDebugReportCallbackCreateInfoEXT32 *in, VkDebugReportCallbackCreateInfoEXT *out)
9467 {
9468     if (!in) return;
9469
9470     out->sType = in->sType;
9471     out->pNext = NULL;
9472     out->flags = in->flags;
9473     out->pfnCallback = in->pfnCallback;
9474     out->pUserData = (void *)UlongToPtr(in->pUserData);
9475     if (in->pNext)
9476         FIXME("Unexpected pNext\n");
9477 }
9478
9479 static inline void convert_VkDebugUtilsMessengerCreateInfoEXT_win32_to_host(const VkDebugUtilsMessengerCreateInfoEXT32 *in, VkDebugUtilsMessengerCreateInfoEXT *out)
9480 {
9481     if (!in) return;
9482
9483     out->sType = in->sType;
9484     out->pNext = NULL;
9485     out->flags = in->flags;
9486     out->messageSeverity = in->messageSeverity;
9487     out->messageType = in->messageType;
9488     out->pfnUserCallback = in->pfnUserCallback;
9489     out->pUserData = (void *)UlongToPtr(in->pUserData);
9490     if (in->pNext)
9491         FIXME("Unexpected pNext\n");
9492 }
9493
9494 static inline void convert_VkMutableDescriptorTypeListEXT_win32_to_host(const VkMutableDescriptorTypeListEXT32 *in, VkMutableDescriptorTypeListEXT *out)
9495 {
9496     if (!in) return;
9497
9498     out->descriptorTypeCount = in->descriptorTypeCount;
9499     out->pDescriptorTypes = (const VkDescriptorType *)UlongToPtr(in->pDescriptorTypes);
9500 }
9501
9502 static inline const VkMutableDescriptorTypeListEXT *convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(struct conversion_context *ctx, const VkMutableDescriptorTypeListEXT32 *in, uint32_t count)
9503 {
9504     VkMutableDescriptorTypeListEXT *out;
9505     unsigned int i;
9506
9507     if (!in || !count) return NULL;
9508
9509     out = conversion_context_alloc(ctx, count * sizeof(*out));
9510     for (i = 0; i < count; i++)
9511     {
9512         convert_VkMutableDescriptorTypeListEXT_win32_to_host(&in[i], &out[i]);
9513     }
9514
9515     return out;
9516 }
9517
9518 static inline void convert_VkDescriptorPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorPoolCreateInfo32 *in, VkDescriptorPoolCreateInfo *out)
9519 {
9520     const VkBaseInStructure32 *in_header;
9521     VkBaseOutStructure *out_header = (void *)out;
9522
9523     if (!in) return;
9524
9525     out->sType = in->sType;
9526     out->pNext = NULL;
9527     out->flags = in->flags;
9528     out->maxSets = in->maxSets;
9529     out->poolSizeCount = in->poolSizeCount;
9530     out->pPoolSizes = (const VkDescriptorPoolSize *)UlongToPtr(in->pPoolSizes);
9531
9532     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9533     {
9534         switch (in_header->sType)
9535         {
9536         case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
9537         {
9538             VkDescriptorPoolInlineUniformBlockCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9539             const VkDescriptorPoolInlineUniformBlockCreateInfo32 *in_ext = (const VkDescriptorPoolInlineUniformBlockCreateInfo32 *)in_header;
9540             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO;
9541             out_ext->pNext = NULL;
9542             out_ext->maxInlineUniformBlockBindings = in_ext->maxInlineUniformBlockBindings;
9543             out_header->pNext = (void *)out_ext;
9544             out_header = (void *)out_ext;
9545             break;
9546         }
9547         case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
9548         {
9549             VkMutableDescriptorTypeCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9550             const VkMutableDescriptorTypeCreateInfoEXT32 *in_ext = (const VkMutableDescriptorTypeCreateInfoEXT32 *)in_header;
9551             out_ext->sType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
9552             out_ext->pNext = NULL;
9553             out_ext->mutableDescriptorTypeListCount = in_ext->mutableDescriptorTypeListCount;
9554             out_ext->pMutableDescriptorTypeLists = convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(ctx, (const VkMutableDescriptorTypeListEXT32 *)UlongToPtr(in_ext->pMutableDescriptorTypeLists), in_ext->mutableDescriptorTypeListCount);
9555             out_header->pNext = (void *)out_ext;
9556             out_header = (void *)out_ext;
9557             break;
9558         }
9559         default:
9560             FIXME("Unhandled sType %u.\n", in_header->sType);
9561             break;
9562         }
9563     }
9564 }
9565
9566 static inline void convert_VkDescriptorSetLayoutBinding_win32_to_host(const VkDescriptorSetLayoutBinding32 *in, VkDescriptorSetLayoutBinding *out)
9567 {
9568     if (!in) return;
9569
9570     out->binding = in->binding;
9571     out->descriptorType = in->descriptorType;
9572     out->descriptorCount = in->descriptorCount;
9573     out->stageFlags = in->stageFlags;
9574     out->pImmutableSamplers = (const VkSampler *)UlongToPtr(in->pImmutableSamplers);
9575 }
9576
9577 static inline const VkDescriptorSetLayoutBinding *convert_VkDescriptorSetLayoutBinding_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutBinding32 *in, uint32_t count)
9578 {
9579     VkDescriptorSetLayoutBinding *out;
9580     unsigned int i;
9581
9582     if (!in || !count) return NULL;
9583
9584     out = conversion_context_alloc(ctx, count * sizeof(*out));
9585     for (i = 0; i < count; i++)
9586     {
9587         convert_VkDescriptorSetLayoutBinding_win32_to_host(&in[i], &out[i]);
9588     }
9589
9590     return out;
9591 }
9592
9593 static inline void convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutCreateInfo32 *in, VkDescriptorSetLayoutCreateInfo *out)
9594 {
9595     const VkBaseInStructure32 *in_header;
9596     VkBaseOutStructure *out_header = (void *)out;
9597
9598     if (!in) return;
9599
9600     out->sType = in->sType;
9601     out->pNext = NULL;
9602     out->flags = in->flags;
9603     out->bindingCount = in->bindingCount;
9604     out->pBindings = convert_VkDescriptorSetLayoutBinding_array_win32_to_host(ctx, (const VkDescriptorSetLayoutBinding32 *)UlongToPtr(in->pBindings), in->bindingCount);
9605
9606     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9607     {
9608         switch (in_header->sType)
9609         {
9610         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
9611         {
9612             VkDescriptorSetLayoutBindingFlagsCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9613             const VkDescriptorSetLayoutBindingFlagsCreateInfo32 *in_ext = (const VkDescriptorSetLayoutBindingFlagsCreateInfo32 *)in_header;
9614             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
9615             out_ext->pNext = NULL;
9616             out_ext->bindingCount = in_ext->bindingCount;
9617             out_ext->pBindingFlags = (const VkDescriptorBindingFlags *)UlongToPtr(in_ext->pBindingFlags);
9618             out_header->pNext = (void *)out_ext;
9619             out_header = (void *)out_ext;
9620             break;
9621         }
9622         case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
9623         {
9624             VkMutableDescriptorTypeCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9625             const VkMutableDescriptorTypeCreateInfoEXT32 *in_ext = (const VkMutableDescriptorTypeCreateInfoEXT32 *)in_header;
9626             out_ext->sType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
9627             out_ext->pNext = NULL;
9628             out_ext->mutableDescriptorTypeListCount = in_ext->mutableDescriptorTypeListCount;
9629             out_ext->pMutableDescriptorTypeLists = convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(ctx, (const VkMutableDescriptorTypeListEXT32 *)UlongToPtr(in_ext->pMutableDescriptorTypeLists), in_ext->mutableDescriptorTypeListCount);
9630             out_header->pNext = (void *)out_ext;
9631             out_header = (void *)out_ext;
9632             break;
9633         }
9634         default:
9635             FIXME("Unhandled sType %u.\n", in_header->sType);
9636             break;
9637         }
9638     }
9639 }
9640
9641 static inline void convert_VkDescriptorUpdateTemplateEntry_win32_to_host(const VkDescriptorUpdateTemplateEntry32 *in, VkDescriptorUpdateTemplateEntry *out)
9642 {
9643     if (!in) return;
9644
9645     out->dstBinding = in->dstBinding;
9646     out->dstArrayElement = in->dstArrayElement;
9647     out->descriptorCount = in->descriptorCount;
9648     out->descriptorType = in->descriptorType;
9649     out->offset = in->offset;
9650     out->stride = in->stride;
9651 }
9652
9653 static inline const VkDescriptorUpdateTemplateEntry *convert_VkDescriptorUpdateTemplateEntry_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorUpdateTemplateEntry32 *in, uint32_t count)
9654 {
9655     VkDescriptorUpdateTemplateEntry *out;
9656     unsigned int i;
9657
9658     if (!in || !count) return NULL;
9659
9660     out = conversion_context_alloc(ctx, count * sizeof(*out));
9661     for (i = 0; i < count; i++)
9662     {
9663         convert_VkDescriptorUpdateTemplateEntry_win32_to_host(&in[i], &out[i]);
9664     }
9665
9666     return out;
9667 }
9668
9669 static inline void convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorUpdateTemplateCreateInfo32 *in, VkDescriptorUpdateTemplateCreateInfo *out)
9670 {
9671     if (!in) return;
9672
9673     out->sType = in->sType;
9674     out->pNext = NULL;
9675     out->flags = in->flags;
9676     out->descriptorUpdateEntryCount = in->descriptorUpdateEntryCount;
9677     out->pDescriptorUpdateEntries = convert_VkDescriptorUpdateTemplateEntry_array_win32_to_host(ctx, (const VkDescriptorUpdateTemplateEntry32 *)UlongToPtr(in->pDescriptorUpdateEntries), in->descriptorUpdateEntryCount);
9678     out->templateType = in->templateType;
9679     out->descriptorSetLayout = in->descriptorSetLayout;
9680     out->pipelineBindPoint = in->pipelineBindPoint;
9681     out->pipelineLayout = in->pipelineLayout;
9682     out->set = in->set;
9683     if (in->pNext)
9684         FIXME("Unexpected pNext\n");
9685 }
9686
9687 #ifdef _WIN64
9688 static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win64_to_host(struct conversion_context *ctx, const VkPhysicalDevice *in, uint32_t count)
9689 {
9690     VkPhysicalDevice *out;
9691     unsigned int i;
9692
9693     if (!in || !count) return NULL;
9694
9695     out = conversion_context_alloc(ctx, count * sizeof(*out));
9696     for (i = 0; i < count; i++)
9697     {
9698         out[i] = wine_phys_dev_from_handle(in[i])->phys_dev;
9699     }
9700
9701     return out;
9702 }
9703 #endif /* _WIN64 */
9704
9705 static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
9706 {
9707     VkPhysicalDevice *out;
9708     unsigned int i;
9709
9710     if (!in || !count) return NULL;
9711
9712     out = conversion_context_alloc(ctx, count * sizeof(*out));
9713     for (i = 0; i < count; i++)
9714     {
9715         out[i] = wine_phys_dev_from_handle(UlongToPtr(in[i]))->phys_dev;
9716     }
9717
9718     return out;
9719 }
9720
9721 static inline void convert_VkDeviceQueueCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceQueueCreateInfo32 *in, VkDeviceQueueCreateInfo *out)
9722 {
9723     const VkBaseInStructure32 *in_header;
9724     VkBaseOutStructure *out_header = (void *)out;
9725
9726     if (!in) return;
9727
9728     out->sType = in->sType;
9729     out->pNext = NULL;
9730     out->flags = in->flags;
9731     out->queueFamilyIndex = in->queueFamilyIndex;
9732     out->queueCount = in->queueCount;
9733     out->pQueuePriorities = (const float *)UlongToPtr(in->pQueuePriorities);
9734
9735     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9736     {
9737         switch (in_header->sType)
9738         {
9739         case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR:
9740         {
9741             VkDeviceQueueGlobalPriorityCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9742             const VkDeviceQueueGlobalPriorityCreateInfoKHR32 *in_ext = (const VkDeviceQueueGlobalPriorityCreateInfoKHR32 *)in_header;
9743             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR;
9744             out_ext->pNext = NULL;
9745             out_ext->globalPriority = in_ext->globalPriority;
9746             out_header->pNext = (void *)out_ext;
9747             out_header = (void *)out_ext;
9748             break;
9749         }
9750         default:
9751             FIXME("Unhandled sType %u.\n", in_header->sType);
9752             break;
9753         }
9754     }
9755 }
9756
9757 static inline const VkDeviceQueueCreateInfo *convert_VkDeviceQueueCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkDeviceQueueCreateInfo32 *in, uint32_t count)
9758 {
9759     VkDeviceQueueCreateInfo *out;
9760     unsigned int i;
9761
9762     if (!in || !count) return NULL;
9763
9764     out = conversion_context_alloc(ctx, count * sizeof(*out));
9765     for (i = 0; i < count; i++)
9766     {
9767         convert_VkDeviceQueueCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
9768     }
9769
9770     return out;
9771 }
9772
9773 static inline const char * const*convert_char_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
9774 {
9775     char **out;
9776     unsigned int i;
9777
9778     if (!in || !count) return NULL;
9779
9780     out = conversion_context_alloc(ctx, count * sizeof(*out));
9781     for (i = 0; i < count; i++)
9782     {
9783         out[i] = UlongToPtr(in[i]);
9784     }
9785
9786     return (void *)out;
9787 }
9788
9789 #ifdef _WIN64
9790 static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo *in, VkDeviceCreateInfo *out)
9791 {
9792     const VkBaseInStructure *in_header;
9793     VkBaseOutStructure *out_header = (void *)out;
9794
9795     if (!in) return;
9796
9797     out->sType = in->sType;
9798     out->pNext = NULL;
9799     out->flags = in->flags;
9800     out->queueCreateInfoCount = in->queueCreateInfoCount;
9801     out->pQueueCreateInfos = in->pQueueCreateInfos;
9802     out->enabledLayerCount = in->enabledLayerCount;
9803     out->ppEnabledLayerNames = in->ppEnabledLayerNames;
9804     out->enabledExtensionCount = in->enabledExtensionCount;
9805     out->ppEnabledExtensionNames = in->ppEnabledExtensionNames;
9806     out->pEnabledFeatures = in->pEnabledFeatures;
9807
9808     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
9809     {
9810         switch (in_header->sType)
9811         {
9812         case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
9813             break;
9814         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
9815         {
9816             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9817             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header;
9818             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
9819             out_ext->pNext = NULL;
9820             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
9821             out_header->pNext = (void *)out_ext;
9822             out_header = (void *)out_ext;
9823             break;
9824         }
9825         case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
9826         {
9827             VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9828             const VkDevicePrivateDataCreateInfo *in_ext = (const VkDevicePrivateDataCreateInfo *)in_header;
9829             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
9830             out_ext->pNext = NULL;
9831             out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount;
9832             out_header->pNext = (void *)out_ext;
9833             out_header = (void *)out_ext;
9834             break;
9835         }
9836         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
9837         {
9838             VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9839             const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header;
9840             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
9841             out_ext->pNext = NULL;
9842             out_ext->privateData = in_ext->privateData;
9843             out_header->pNext = (void *)out_ext;
9844             out_header = (void *)out_ext;
9845             break;
9846         }
9847         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
9848         {
9849             VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9850             const VkPhysicalDeviceFeatures2 *in_ext = (const VkPhysicalDeviceFeatures2 *)in_header;
9851             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
9852             out_ext->pNext = NULL;
9853             out_ext->features = in_ext->features;
9854             out_header->pNext = (void *)out_ext;
9855             out_header = (void *)out_ext;
9856             break;
9857         }
9858         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
9859         {
9860             VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9861             const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header;
9862             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
9863             out_ext->pNext = NULL;
9864             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
9865             out_ext->variablePointers = in_ext->variablePointers;
9866             out_header->pNext = (void *)out_ext;
9867             out_header = (void *)out_ext;
9868             break;
9869         }
9870         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
9871         {
9872             VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9873             const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header;
9874             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
9875             out_ext->pNext = NULL;
9876             out_ext->multiview = in_ext->multiview;
9877             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
9878             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
9879             out_header->pNext = (void *)out_ext;
9880             out_header = (void *)out_ext;
9881             break;
9882         }
9883         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
9884         {
9885             VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9886             const VkDeviceGroupDeviceCreateInfo *in_ext = (const VkDeviceGroupDeviceCreateInfo *)in_header;
9887             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
9888             out_ext->pNext = NULL;
9889             out_ext->physicalDeviceCount = in_ext->physicalDeviceCount;
9890             out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win64_to_host(ctx, in_ext->pPhysicalDevices, in_ext->physicalDeviceCount);
9891             out_header->pNext = (void *)out_ext;
9892             out_header = (void *)out_ext;
9893             break;
9894         }
9895         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
9896         {
9897             VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9898             const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header;
9899             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
9900             out_ext->pNext = NULL;
9901             out_ext->presentId = in_ext->presentId;
9902             out_header->pNext = (void *)out_ext;
9903             out_header = (void *)out_ext;
9904             break;
9905         }
9906         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
9907         {
9908             VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9909             const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header;
9910             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
9911             out_ext->pNext = NULL;
9912             out_ext->presentWait = in_ext->presentWait;
9913             out_header->pNext = (void *)out_ext;
9914             out_header = (void *)out_ext;
9915             break;
9916         }
9917         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
9918         {
9919             VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9920             const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header;
9921             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
9922             out_ext->pNext = NULL;
9923             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
9924             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
9925             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
9926             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
9927             out_header->pNext = (void *)out_ext;
9928             out_header = (void *)out_ext;
9929             break;
9930         }
9931         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
9932         {
9933             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9934             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header;
9935             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
9936             out_ext->pNext = NULL;
9937             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
9938             out_header->pNext = (void *)out_ext;
9939             out_header = (void *)out_ext;
9940             break;
9941         }
9942         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
9943         {
9944             VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9945             const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header;
9946             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
9947             out_ext->pNext = NULL;
9948             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
9949             out_header->pNext = (void *)out_ext;
9950             out_header = (void *)out_ext;
9951             break;
9952         }
9953         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
9954         {
9955             VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9956             const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header;
9957             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
9958             out_ext->pNext = NULL;
9959             out_ext->protectedMemory = in_ext->protectedMemory;
9960             out_header->pNext = (void *)out_ext;
9961             out_header = (void *)out_ext;
9962             break;
9963         }
9964         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
9965         {
9966             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9967             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)in_header;
9968             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
9969             out_ext->pNext = NULL;
9970             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
9971             out_header->pNext = (void *)out_ext;
9972             out_header = (void *)out_ext;
9973             break;
9974         }
9975         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
9976         {
9977             VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9978             const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header;
9979             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
9980             out_ext->pNext = NULL;
9981             out_ext->multiDraw = in_ext->multiDraw;
9982             out_header->pNext = (void *)out_ext;
9983             out_header = (void *)out_ext;
9984             break;
9985         }
9986         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
9987         {
9988             VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9989             const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header;
9990             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
9991             out_ext->pNext = NULL;
9992             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
9993             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
9994             out_header->pNext = (void *)out_ext;
9995             out_header = (void *)out_ext;
9996             break;
9997         }
9998         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
9999         {
10000             VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10001             const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header;
10002             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
10003             out_ext->pNext = NULL;
10004             out_ext->maintenance4 = in_ext->maintenance4;
10005             out_header->pNext = (void *)out_ext;
10006             out_header = (void *)out_ext;
10007             break;
10008         }
10009         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
10010         {
10011             VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10012             const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header;
10013             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
10014             out_ext->pNext = NULL;
10015             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
10016             out_header->pNext = (void *)out_ext;
10017             out_header = (void *)out_ext;
10018             break;
10019         }
10020         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
10021         {
10022             VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10023             const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header;
10024             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
10025             out_ext->pNext = NULL;
10026             out_ext->shaderFloat16 = in_ext->shaderFloat16;
10027             out_ext->shaderInt8 = in_ext->shaderInt8;
10028             out_header->pNext = (void *)out_ext;
10029             out_header = (void *)out_ext;
10030             break;
10031         }
10032         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
10033         {
10034             VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10035             const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header;
10036             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
10037             out_ext->pNext = NULL;
10038             out_ext->hostQueryReset = in_ext->hostQueryReset;
10039             out_header->pNext = (void *)out_ext;
10040             out_header = (void *)out_ext;
10041             break;
10042         }
10043         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
10044         {
10045             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10046             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *)in_header;
10047             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
10048             out_ext->pNext = NULL;
10049             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
10050             out_header->pNext = (void *)out_ext;
10051             out_header = (void *)out_ext;
10052             break;
10053         }
10054         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
10055         {
10056             VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10057             const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header;
10058             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
10059             out_ext->pNext = NULL;
10060             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
10061             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
10062             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
10063             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
10064             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
10065             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
10066             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
10067             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
10068             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
10069             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
10070             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
10071             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
10072             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
10073             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
10074             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
10075             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
10076             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
10077             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
10078             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
10079             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
10080             out_header->pNext = (void *)out_ext;
10081             out_header = (void *)out_ext;
10082             break;
10083         }
10084         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
10085         {
10086             VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10087             const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header;
10088             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
10089             out_ext->pNext = NULL;
10090             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
10091             out_header->pNext = (void *)out_ext;
10092             out_header = (void *)out_ext;
10093             break;
10094         }
10095         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
10096         {
10097             VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10098             const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header;
10099             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
10100             out_ext->pNext = NULL;
10101             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
10102             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
10103             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
10104             out_header->pNext = (void *)out_ext;
10105             out_header = (void *)out_ext;
10106             break;
10107         }
10108         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
10109         {
10110             VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10111             const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header;
10112             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
10113             out_ext->pNext = NULL;
10114             out_ext->conditionalRendering = in_ext->conditionalRendering;
10115             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
10116             out_header->pNext = (void *)out_ext;
10117             out_header = (void *)out_ext;
10118             break;
10119         }
10120         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
10121         {
10122             VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10123             const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header;
10124             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
10125             out_ext->pNext = NULL;
10126             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
10127             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
10128             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
10129             out_header->pNext = (void *)out_ext;
10130             out_header = (void *)out_ext;
10131             break;
10132         }
10133         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
10134         {
10135             VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10136             const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header;
10137             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
10138             out_ext->pNext = NULL;
10139             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
10140             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
10141             out_header->pNext = (void *)out_ext;
10142             out_header = (void *)out_ext;
10143             break;
10144         }
10145         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
10146         {
10147             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10148             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header;
10149             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
10150             out_ext->pNext = NULL;
10151             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
10152             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
10153             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
10154             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
10155             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
10156             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
10157             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
10158             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
10159             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
10160             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
10161             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
10162             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
10163             out_header->pNext = (void *)out_ext;
10164             out_header = (void *)out_ext;
10165             break;
10166         }
10167         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
10168         {
10169             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10170             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header;
10171             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
10172             out_ext->pNext = NULL;
10173             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
10174             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
10175             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
10176             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
10177             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
10178             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
10179             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
10180             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
10181             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
10182             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
10183             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
10184             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
10185             out_header->pNext = (void *)out_ext;
10186             out_header = (void *)out_ext;
10187             break;
10188         }
10189         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
10190         {
10191             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10192             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)in_header;
10193             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
10194             out_ext->pNext = NULL;
10195             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
10196             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
10197             out_header->pNext = (void *)out_ext;
10198             out_header = (void *)out_ext;
10199             break;
10200         }
10201         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
10202         {
10203             VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10204             const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header;
10205             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
10206             out_ext->pNext = NULL;
10207             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
10208             out_header->pNext = (void *)out_ext;
10209             out_header = (void *)out_ext;
10210             break;
10211         }
10212         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
10213         {
10214             VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10215             const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header;
10216             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
10217             out_ext->pNext = NULL;
10218             out_ext->transformFeedback = in_ext->transformFeedback;
10219             out_ext->geometryStreams = in_ext->geometryStreams;
10220             out_header->pNext = (void *)out_ext;
10221             out_header = (void *)out_ext;
10222             break;
10223         }
10224         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
10225         {
10226             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10227             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header;
10228             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
10229             out_ext->pNext = NULL;
10230             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
10231             out_header->pNext = (void *)out_ext;
10232             out_header = (void *)out_ext;
10233             break;
10234         }
10235         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
10236         {
10237             VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10238             const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header;
10239             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
10240             out_ext->pNext = NULL;
10241             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
10242             out_header->pNext = (void *)out_ext;
10243             out_header = (void *)out_ext;
10244             break;
10245         }
10246         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
10247         {
10248             VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10249             const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header;
10250             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
10251             out_ext->pNext = NULL;
10252             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
10253             out_header->pNext = (void *)out_ext;
10254             out_header = (void *)out_ext;
10255             break;
10256         }
10257         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
10258         {
10259             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10260             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *)in_header;
10261             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
10262             out_ext->pNext = NULL;
10263             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
10264             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
10265             out_header->pNext = (void *)out_ext;
10266             out_header = (void *)out_ext;
10267             break;
10268         }
10269         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
10270         {
10271             VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10272             const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header;
10273             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
10274             out_ext->pNext = NULL;
10275             out_ext->imageFootprint = in_ext->imageFootprint;
10276             out_header->pNext = (void *)out_ext;
10277             out_header = (void *)out_ext;
10278             break;
10279         }
10280         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
10281         {
10282             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10283             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header;
10284             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
10285             out_ext->pNext = NULL;
10286             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
10287             out_header->pNext = (void *)out_ext;
10288             out_header = (void *)out_ext;
10289             break;
10290         }
10291         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
10292         {
10293             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10294             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header;
10295             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
10296             out_ext->pNext = NULL;
10297             out_ext->indirectCopy = in_ext->indirectCopy;
10298             out_header->pNext = (void *)out_ext;
10299             out_header = (void *)out_ext;
10300             break;
10301         }
10302         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
10303         {
10304             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10305             const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header;
10306             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
10307             out_ext->pNext = NULL;
10308             out_ext->memoryDecompression = in_ext->memoryDecompression;
10309             out_header->pNext = (void *)out_ext;
10310             out_header = (void *)out_ext;
10311             break;
10312         }
10313         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
10314         {
10315             VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10316             const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header;
10317             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
10318             out_ext->pNext = NULL;
10319             out_ext->shadingRateImage = in_ext->shadingRateImage;
10320             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
10321             out_header->pNext = (void *)out_ext;
10322             out_header = (void *)out_ext;
10323             break;
10324         }
10325         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
10326         {
10327             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10328             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header;
10329             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
10330             out_ext->pNext = NULL;
10331             out_ext->invocationMask = in_ext->invocationMask;
10332             out_header->pNext = (void *)out_ext;
10333             out_header = (void *)out_ext;
10334             break;
10335         }
10336         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
10337         {
10338             VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10339             const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header;
10340             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
10341             out_ext->pNext = NULL;
10342             out_ext->taskShader = in_ext->taskShader;
10343             out_ext->meshShader = in_ext->meshShader;
10344             out_header->pNext = (void *)out_ext;
10345             out_header = (void *)out_ext;
10346             break;
10347         }
10348         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
10349         {
10350             VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10351             const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header;
10352             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
10353             out_ext->pNext = NULL;
10354             out_ext->taskShader = in_ext->taskShader;
10355             out_ext->meshShader = in_ext->meshShader;
10356             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
10357             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
10358             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
10359             out_header->pNext = (void *)out_ext;
10360             out_header = (void *)out_ext;
10361             break;
10362         }
10363         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
10364         {
10365             VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10366             const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header;
10367             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
10368             out_ext->pNext = NULL;
10369             out_ext->accelerationStructure = in_ext->accelerationStructure;
10370             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
10371             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
10372             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
10373             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
10374             out_header->pNext = (void *)out_ext;
10375             out_header = (void *)out_ext;
10376             break;
10377         }
10378         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
10379         {
10380             VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10381             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header;
10382             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
10383             out_ext->pNext = NULL;
10384             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
10385             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
10386             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
10387             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
10388             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
10389             out_header->pNext = (void *)out_ext;
10390             out_header = (void *)out_ext;
10391             break;
10392         }
10393         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
10394         {
10395             VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10396             const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header;
10397             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
10398             out_ext->pNext = NULL;
10399             out_ext->rayQuery = in_ext->rayQuery;
10400             out_header->pNext = (void *)out_ext;
10401             out_header = (void *)out_ext;
10402             break;
10403         }
10404         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
10405         {
10406             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10407             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header;
10408             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
10409             out_ext->pNext = NULL;
10410             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
10411             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
10412             out_header->pNext = (void *)out_ext;
10413             out_header = (void *)out_ext;
10414             break;
10415         }
10416         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
10417         {
10418             VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10419             const VkDeviceMemoryOverallocationCreateInfoAMD *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD *)in_header;
10420             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD;
10421             out_ext->pNext = NULL;
10422             out_ext->overallocationBehavior = in_ext->overallocationBehavior;
10423             out_header->pNext = (void *)out_ext;
10424             out_header = (void *)out_ext;
10425             break;
10426         }
10427         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
10428         {
10429             VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10430             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)in_header;
10431             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
10432             out_ext->pNext = NULL;
10433             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
10434             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
10435             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
10436             out_header->pNext = (void *)out_ext;
10437             out_header = (void *)out_ext;
10438             break;
10439         }
10440         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
10441         {
10442             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10443             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header;
10444             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
10445             out_ext->pNext = NULL;
10446             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
10447             out_header->pNext = (void *)out_ext;
10448             out_header = (void *)out_ext;
10449             break;
10450         }
10451         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
10452         {
10453             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10454             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *)in_header;
10455             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
10456             out_ext->pNext = NULL;
10457             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
10458             out_header->pNext = (void *)out_ext;
10459             out_header = (void *)out_ext;
10460             break;
10461         }
10462         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
10463         {
10464             VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10465             const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header;
10466             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
10467             out_ext->pNext = NULL;
10468             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
10469             out_header->pNext = (void *)out_ext;
10470             out_header = (void *)out_ext;
10471             break;
10472         }
10473         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
10474         {
10475             VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10476             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header;
10477             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
10478             out_ext->pNext = NULL;
10479             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
10480             out_header->pNext = (void *)out_ext;
10481             out_header = (void *)out_ext;
10482             break;
10483         }
10484         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
10485         {
10486             VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10487             const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header;
10488             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
10489             out_ext->pNext = NULL;
10490             out_ext->depthClipEnable = in_ext->depthClipEnable;
10491             out_header->pNext = (void *)out_ext;
10492             out_header = (void *)out_ext;
10493             break;
10494         }
10495         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
10496         {
10497             VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10498             const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header;
10499             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
10500             out_ext->pNext = NULL;
10501             out_ext->memoryPriority = in_ext->memoryPriority;
10502             out_header->pNext = (void *)out_ext;
10503             out_header = (void *)out_ext;
10504             break;
10505         }
10506         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
10507         {
10508             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10509             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header;
10510             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
10511             out_ext->pNext = NULL;
10512             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
10513             out_header->pNext = (void *)out_ext;
10514             out_header = (void *)out_ext;
10515             break;
10516         }
10517         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
10518         {
10519             VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10520             const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header;
10521             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
10522             out_ext->pNext = NULL;
10523             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
10524             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
10525             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
10526             out_header->pNext = (void *)out_ext;
10527             out_header = (void *)out_ext;
10528             break;
10529         }
10530         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
10531         {
10532             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10533             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header;
10534             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
10535             out_ext->pNext = NULL;
10536             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
10537             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
10538             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
10539             out_header->pNext = (void *)out_ext;
10540             out_header = (void *)out_ext;
10541             break;
10542         }
10543         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
10544         {
10545             VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10546             const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header;
10547             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
10548             out_ext->pNext = NULL;
10549             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
10550             out_header->pNext = (void *)out_ext;
10551             out_header = (void *)out_ext;
10552             break;
10553         }
10554         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
10555         {
10556             VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10557             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header;
10558             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
10559             out_ext->pNext = NULL;
10560             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
10561             out_header->pNext = (void *)out_ext;
10562             out_header = (void *)out_ext;
10563             break;
10564         }
10565         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
10566         {
10567             VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10568             const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header;
10569             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
10570             out_ext->pNext = NULL;
10571             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
10572             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
10573             out_header->pNext = (void *)out_ext;
10574             out_header = (void *)out_ext;
10575             break;
10576         }
10577         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
10578         {
10579             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10580             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header;
10581             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
10582             out_ext->pNext = NULL;
10583             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
10584             out_header->pNext = (void *)out_ext;
10585             out_header = (void *)out_ext;
10586             break;
10587         }
10588         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
10589         {
10590             VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10591             const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header;
10592             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
10593             out_ext->pNext = NULL;
10594             out_ext->presentBarrier = in_ext->presentBarrier;
10595             out_header->pNext = (void *)out_ext;
10596             out_header = (void *)out_ext;
10597             break;
10598         }
10599         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
10600         {
10601             VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10602             const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header;
10603             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
10604             out_ext->pNext = NULL;
10605             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
10606             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
10607             out_header->pNext = (void *)out_ext;
10608             out_header = (void *)out_ext;
10609             break;
10610         }
10611         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
10612         {
10613             VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10614             const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header;
10615             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
10616             out_ext->pNext = NULL;
10617             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
10618             out_header->pNext = (void *)out_ext;
10619             out_header = (void *)out_ext;
10620             break;
10621         }
10622         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
10623         {
10624             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10625             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header;
10626             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
10627             out_ext->pNext = NULL;
10628             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
10629             out_header->pNext = (void *)out_ext;
10630             out_header = (void *)out_ext;
10631             break;
10632         }
10633         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
10634         {
10635             VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10636             const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header;
10637             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
10638             out_ext->pNext = NULL;
10639             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
10640             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
10641             out_header->pNext = (void *)out_ext;
10642             out_header = (void *)out_ext;
10643             break;
10644         }
10645         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
10646         {
10647             VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10648             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)in_header;
10649             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
10650             out_ext->pNext = NULL;
10651             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
10652             out_header->pNext = (void *)out_ext;
10653             out_header = (void *)out_ext;
10654             break;
10655         }
10656         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
10657         {
10658             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10659             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header;
10660             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
10661             out_ext->pNext = NULL;
10662             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
10663             out_header->pNext = (void *)out_ext;
10664             out_header = (void *)out_ext;
10665             break;
10666         }
10667         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
10668         {
10669             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10670             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header;
10671             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
10672             out_ext->pNext = NULL;
10673             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
10674             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
10675             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
10676             out_header->pNext = (void *)out_ext;
10677             out_header = (void *)out_ext;
10678             break;
10679         }
10680         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
10681         {
10682             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10683             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header;
10684             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
10685             out_ext->pNext = NULL;
10686             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
10687             out_header->pNext = (void *)out_ext;
10688             out_header = (void *)out_ext;
10689             break;
10690         }
10691         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
10692         {
10693             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10694             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header;
10695             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
10696             out_ext->pNext = NULL;
10697             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
10698             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
10699             out_header->pNext = (void *)out_ext;
10700             out_header = (void *)out_ext;
10701             break;
10702         }
10703         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
10704         {
10705             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10706             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header;
10707             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
10708             out_ext->pNext = NULL;
10709             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
10710             out_header->pNext = (void *)out_ext;
10711             out_header = (void *)out_ext;
10712             break;
10713         }
10714         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
10715         {
10716             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10717             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header;
10718             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
10719             out_ext->pNext = NULL;
10720             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
10721             out_header->pNext = (void *)out_ext;
10722             out_header = (void *)out_ext;
10723             break;
10724         }
10725         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
10726         {
10727             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10728             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header;
10729             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
10730             out_ext->pNext = NULL;
10731             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
10732             out_header->pNext = (void *)out_ext;
10733             out_header = (void *)out_ext;
10734             break;
10735         }
10736         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
10737         {
10738             VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10739             const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header;
10740             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
10741             out_ext->pNext = NULL;
10742             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
10743             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
10744             out_header->pNext = (void *)out_ext;
10745             out_header = (void *)out_ext;
10746             break;
10747         }
10748         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
10749         {
10750             VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10751             const VkPhysicalDeviceLineRasterizationFeaturesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)in_header;
10752             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
10753             out_ext->pNext = NULL;
10754             out_ext->rectangularLines = in_ext->rectangularLines;
10755             out_ext->bresenhamLines = in_ext->bresenhamLines;
10756             out_ext->smoothLines = in_ext->smoothLines;
10757             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
10758             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
10759             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
10760             out_header->pNext = (void *)out_ext;
10761             out_header = (void *)out_ext;
10762             break;
10763         }
10764         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
10765         {
10766             VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10767             const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header;
10768             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
10769             out_ext->pNext = NULL;
10770             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
10771             out_header->pNext = (void *)out_ext;
10772             out_header = (void *)out_ext;
10773             break;
10774         }
10775         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
10776         {
10777             VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10778             const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header;
10779             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
10780             out_ext->pNext = NULL;
10781             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
10782             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
10783             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
10784             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
10785             out_ext->multiview = in_ext->multiview;
10786             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
10787             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
10788             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
10789             out_ext->variablePointers = in_ext->variablePointers;
10790             out_ext->protectedMemory = in_ext->protectedMemory;
10791             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
10792             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
10793             out_header->pNext = (void *)out_ext;
10794             out_header = (void *)out_ext;
10795             break;
10796         }
10797         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
10798         {
10799             VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10800             const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header;
10801             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
10802             out_ext->pNext = NULL;
10803             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
10804             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
10805             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
10806             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
10807             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
10808             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
10809             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
10810             out_ext->shaderFloat16 = in_ext->shaderFloat16;
10811             out_ext->shaderInt8 = in_ext->shaderInt8;
10812             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
10813             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
10814             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
10815             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
10816             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
10817             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
10818             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
10819             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
10820             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
10821             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
10822             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
10823             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
10824             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
10825             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
10826             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
10827             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
10828             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
10829             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
10830             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
10831             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
10832             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
10833             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
10834             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
10835             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
10836             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
10837             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
10838             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
10839             out_ext->hostQueryReset = in_ext->hostQueryReset;
10840             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
10841             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
10842             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
10843             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
10844             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
10845             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
10846             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
10847             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
10848             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
10849             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
10850             out_header->pNext = (void *)out_ext;
10851             out_header = (void *)out_ext;
10852             break;
10853         }
10854         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
10855         {
10856             VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10857             const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header;
10858             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
10859             out_ext->pNext = NULL;
10860             out_ext->robustImageAccess = in_ext->robustImageAccess;
10861             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
10862             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
10863             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
10864             out_ext->privateData = in_ext->privateData;
10865             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
10866             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
10867             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
10868             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
10869             out_ext->synchronization2 = in_ext->synchronization2;
10870             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
10871             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
10872             out_ext->dynamicRendering = in_ext->dynamicRendering;
10873             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
10874             out_ext->maintenance4 = in_ext->maintenance4;
10875             out_header->pNext = (void *)out_ext;
10876             out_header = (void *)out_ext;
10877             break;
10878         }
10879         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
10880         {
10881             VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10882             const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header;
10883             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
10884             out_ext->pNext = NULL;
10885             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
10886             out_header->pNext = (void *)out_ext;
10887             out_header = (void *)out_ext;
10888             break;
10889         }
10890         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
10891         {
10892             VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10893             const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header;
10894             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
10895             out_ext->pNext = NULL;
10896             out_ext->customBorderColors = in_ext->customBorderColors;
10897             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
10898             out_header->pNext = (void *)out_ext;
10899             out_header = (void *)out_ext;
10900             break;
10901         }
10902         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
10903         {
10904             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10905             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header;
10906             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
10907             out_ext->pNext = NULL;
10908             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
10909             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
10910             out_header->pNext = (void *)out_ext;
10911             out_header = (void *)out_ext;
10912             break;
10913         }
10914         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
10915         {
10916             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10917             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header;
10918             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
10919             out_ext->pNext = NULL;
10920             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
10921             out_header->pNext = (void *)out_ext;
10922             out_header = (void *)out_ext;
10923             break;
10924         }
10925         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
10926         {
10927             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10928             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header;
10929             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
10930             out_ext->pNext = NULL;
10931             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
10932             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
10933             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
10934             out_header->pNext = (void *)out_ext;
10935             out_header = (void *)out_ext;
10936             break;
10937         }
10938         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
10939         {
10940             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10941             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header;
10942             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
10943             out_ext->pNext = NULL;
10944             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
10945             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
10946             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
10947             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
10948             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
10949             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
10950             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
10951             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
10952             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
10953             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
10954             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
10955             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
10956             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
10957             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
10958             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
10959             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
10960             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
10961             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
10962             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
10963             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
10964             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
10965             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
10966             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
10967             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
10968             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
10969             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
10970             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
10971             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
10972             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
10973             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
10974             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
10975             out_header->pNext = (void *)out_ext;
10976             out_header = (void *)out_ext;
10977             break;
10978         }
10979         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
10980         {
10981             VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10982             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header;
10983             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
10984             out_ext->pNext = NULL;
10985             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
10986             out_header->pNext = (void *)out_ext;
10987             out_header = (void *)out_ext;
10988             break;
10989         }
10990         case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
10991         {
10992             VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10993             const VkDeviceDiagnosticsConfigCreateInfoNV *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV *)in_header;
10994             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
10995             out_ext->pNext = NULL;
10996             out_ext->flags = in_ext->flags;
10997             out_header->pNext = (void *)out_ext;
10998             out_header = (void *)out_ext;
10999             break;
11000         }
11001         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
11002         {
11003             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11004             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header;
11005             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
11006             out_ext->pNext = NULL;
11007             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
11008             out_header->pNext = (void *)out_ext;
11009             out_header = (void *)out_ext;
11010             break;
11011         }
11012         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
11013         {
11014             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11015             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header;
11016             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
11017             out_ext->pNext = NULL;
11018             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
11019             out_header->pNext = (void *)out_ext;
11020             out_header = (void *)out_ext;
11021             break;
11022         }
11023         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
11024         {
11025             VkPhysicalDeviceRobustness2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11026             const VkPhysicalDeviceRobustness2FeaturesEXT *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT *)in_header;
11027             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
11028             out_ext->pNext = NULL;
11029             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
11030             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
11031             out_ext->nullDescriptor = in_ext->nullDescriptor;
11032             out_header->pNext = (void *)out_ext;
11033             out_header = (void *)out_ext;
11034             break;
11035         }
11036         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
11037         {
11038             VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11039             const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header;
11040             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
11041             out_ext->pNext = NULL;
11042             out_ext->robustImageAccess = in_ext->robustImageAccess;
11043             out_header->pNext = (void *)out_ext;
11044             out_header = (void *)out_ext;
11045             break;
11046         }
11047         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
11048         {
11049             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11050             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header;
11051             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
11052             out_ext->pNext = NULL;
11053             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
11054             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
11055             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
11056             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
11057             out_header->pNext = (void *)out_ext;
11058             out_header = (void *)out_ext;
11059             break;
11060         }
11061         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
11062         {
11063             VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11064             const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header;
11065             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
11066             out_ext->pNext = NULL;
11067             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
11068             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
11069             out_header->pNext = (void *)out_ext;
11070             out_header = (void *)out_ext;
11071             break;
11072         }
11073         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
11074         {
11075             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11076             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header;
11077             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
11078             out_ext->pNext = NULL;
11079             out_ext->subpassShading = in_ext->subpassShading;
11080             out_header->pNext = (void *)out_ext;
11081             out_header = (void *)out_ext;
11082             break;
11083         }
11084         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
11085         {
11086             VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11087             const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *)in_header;
11088             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
11089             out_ext->pNext = NULL;
11090             out_ext->clustercullingShader = in_ext->clustercullingShader;
11091             out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
11092             out_header->pNext = (void *)out_ext;
11093             out_header = (void *)out_ext;
11094             break;
11095         }
11096         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
11097         {
11098             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11099             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header;
11100             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
11101             out_ext->pNext = NULL;
11102             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
11103             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
11104             out_header->pNext = (void *)out_ext;
11105             out_header = (void *)out_ext;
11106             break;
11107         }
11108         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
11109         {
11110             VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11111             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header;
11112             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
11113             out_ext->pNext = NULL;
11114             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
11115             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
11116             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
11117             out_header->pNext = (void *)out_ext;
11118             out_header = (void *)out_ext;
11119             break;
11120         }
11121         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
11122         {
11123             VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11124             const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header;
11125             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
11126             out_ext->pNext = NULL;
11127             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
11128             out_header->pNext = (void *)out_ext;
11129             out_header = (void *)out_ext;
11130             break;
11131         }
11132         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
11133         {
11134             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11135             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header;
11136             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
11137             out_ext->pNext = NULL;
11138             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
11139             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
11140             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
11141             out_header->pNext = (void *)out_ext;
11142             out_header = (void *)out_ext;
11143             break;
11144         }
11145         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
11146         {
11147             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11148             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header;
11149             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
11150             out_ext->pNext = NULL;
11151             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
11152             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
11153             out_header->pNext = (void *)out_ext;
11154             out_header = (void *)out_ext;
11155             break;
11156         }
11157         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
11158         {
11159             VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11160             const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *)in_header;
11161             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
11162             out_ext->pNext = NULL;
11163             out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
11164             out_header->pNext = (void *)out_ext;
11165             out_header = (void *)out_ext;
11166             break;
11167         }
11168         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
11169         {
11170             VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11171             const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *)in_header;
11172             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
11173             out_ext->pNext = NULL;
11174             out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
11175             out_header->pNext = (void *)out_ext;
11176             out_header = (void *)out_ext;
11177             break;
11178         }
11179         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
11180         {
11181             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11182             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header;
11183             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
11184             out_ext->pNext = NULL;
11185             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
11186             out_header->pNext = (void *)out_ext;
11187             out_header = (void *)out_ext;
11188             break;
11189         }
11190         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
11191         {
11192             VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11193             const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header;
11194             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
11195             out_ext->pNext = NULL;
11196             out_ext->depthClipControl = in_ext->depthClipControl;
11197             out_header->pNext = (void *)out_ext;
11198             out_header = (void *)out_ext;
11199             break;
11200         }
11201         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
11202         {
11203             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11204             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header;
11205             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
11206             out_ext->pNext = NULL;
11207             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
11208             out_header->pNext = (void *)out_ext;
11209             out_header = (void *)out_ext;
11210             break;
11211         }
11212         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
11213         {
11214             VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11215             const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header;
11216             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
11217             out_ext->pNext = NULL;
11218             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
11219             out_header->pNext = (void *)out_ext;
11220             out_header = (void *)out_ext;
11221             break;
11222         }
11223         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
11224         {
11225             VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11226             const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header;
11227             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
11228             out_ext->pNext = NULL;
11229             out_ext->synchronization2 = in_ext->synchronization2;
11230             out_header->pNext = (void *)out_ext;
11231             out_header = (void *)out_ext;
11232             break;
11233         }
11234         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
11235         {
11236             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11237             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header;
11238             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
11239             out_ext->pNext = NULL;
11240             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
11241             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
11242             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
11243             out_header->pNext = (void *)out_ext;
11244             out_header = (void *)out_ext;
11245             break;
11246         }
11247         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
11248         {
11249             VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11250             const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header;
11251             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
11252             out_ext->pNext = NULL;
11253             out_ext->legacyDithering = in_ext->legacyDithering;
11254             out_header->pNext = (void *)out_ext;
11255             out_header = (void *)out_ext;
11256             break;
11257         }
11258         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
11259         {
11260             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11261             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header;
11262             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
11263             out_ext->pNext = NULL;
11264             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
11265             out_header->pNext = (void *)out_ext;
11266             out_header = (void *)out_ext;
11267             break;
11268         }
11269         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
11270         {
11271             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11272             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *)in_header;
11273             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
11274             out_ext->pNext = NULL;
11275             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
11276             out_header->pNext = (void *)out_ext;
11277             out_header = (void *)out_ext;
11278             break;
11279         }
11280         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
11281         {
11282             VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11283             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header;
11284             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
11285             out_ext->pNext = NULL;
11286             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
11287             out_header->pNext = (void *)out_ext;
11288             out_header = (void *)out_ext;
11289             break;
11290         }
11291         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
11292         {
11293             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11294             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header;
11295             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
11296             out_ext->pNext = NULL;
11297             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
11298             out_header->pNext = (void *)out_ext;
11299             out_header = (void *)out_ext;
11300             break;
11301         }
11302         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
11303         {
11304             VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11305             const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header;
11306             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
11307             out_ext->pNext = NULL;
11308             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
11309             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
11310             out_header->pNext = (void *)out_ext;
11311             out_header = (void *)out_ext;
11312             break;
11313         }
11314         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
11315         {
11316             VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11317             const VkPhysicalDeviceDescriptorBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)in_header;
11318             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
11319             out_ext->pNext = NULL;
11320             out_ext->descriptorBuffer = in_ext->descriptorBuffer;
11321             out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
11322             out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
11323             out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
11324             out_header->pNext = (void *)out_ext;
11325             out_header = (void *)out_ext;
11326             break;
11327         }
11328         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
11329         {
11330             VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11331             const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header;
11332             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
11333             out_ext->pNext = NULL;
11334             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
11335             out_header->pNext = (void *)out_ext;
11336             out_header = (void *)out_ext;
11337             break;
11338         }
11339         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
11340         {
11341             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11342             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header;
11343             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
11344             out_ext->pNext = NULL;
11345             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
11346             out_header->pNext = (void *)out_ext;
11347             out_header = (void *)out_ext;
11348             break;
11349         }
11350         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
11351         {
11352             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11353             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header;
11354             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
11355             out_ext->pNext = NULL;
11356             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
11357             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
11358             out_header->pNext = (void *)out_ext;
11359             out_header = (void *)out_ext;
11360             break;
11361         }
11362         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
11363         {
11364             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11365             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header;
11366             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
11367             out_ext->pNext = NULL;
11368             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
11369             out_header->pNext = (void *)out_ext;
11370             out_header = (void *)out_ext;
11371             break;
11372         }
11373         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
11374         {
11375             VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11376             const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header;
11377             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
11378             out_ext->pNext = NULL;
11379             out_ext->dynamicRendering = in_ext->dynamicRendering;
11380             out_header->pNext = (void *)out_ext;
11381             out_header = (void *)out_ext;
11382             break;
11383         }
11384         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
11385         {
11386             VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11387             const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header;
11388             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
11389             out_ext->pNext = NULL;
11390             out_ext->minLod = in_ext->minLod;
11391             out_header->pNext = (void *)out_ext;
11392             out_header = (void *)out_ext;
11393             break;
11394         }
11395         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
11396         {
11397             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11398             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header;
11399             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
11400             out_ext->pNext = NULL;
11401             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
11402             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
11403             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
11404             out_header->pNext = (void *)out_ext;
11405             out_header = (void *)out_ext;
11406             break;
11407         }
11408         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
11409         {
11410             VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11411             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header;
11412             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
11413             out_ext->pNext = NULL;
11414             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
11415             out_header->pNext = (void *)out_ext;
11416             out_header = (void *)out_ext;
11417             break;
11418         }
11419         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
11420         {
11421             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11422             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header;
11423             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
11424             out_ext->pNext = NULL;
11425             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
11426             out_header->pNext = (void *)out_ext;
11427             out_header = (void *)out_ext;
11428             break;
11429         }
11430         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
11431         {
11432             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11433             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header;
11434             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
11435             out_ext->pNext = NULL;
11436             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
11437             out_header->pNext = (void *)out_ext;
11438             out_header = (void *)out_ext;
11439             break;
11440         }
11441         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
11442         {
11443             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11444             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header;
11445             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
11446             out_ext->pNext = NULL;
11447             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
11448             out_header->pNext = (void *)out_ext;
11449             out_header = (void *)out_ext;
11450             break;
11451         }
11452         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
11453         {
11454             VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11455             const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header;
11456             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
11457             out_ext->pNext = NULL;
11458             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
11459             out_header->pNext = (void *)out_ext;
11460             out_header = (void *)out_ext;
11461             break;
11462         }
11463         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
11464         {
11465             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11466             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header;
11467             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
11468             out_ext->pNext = NULL;
11469             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
11470             out_header->pNext = (void *)out_ext;
11471             out_header = (void *)out_ext;
11472             break;
11473         }
11474         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
11475         {
11476             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11477             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header;
11478             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
11479             out_ext->pNext = NULL;
11480             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
11481             out_header->pNext = (void *)out_ext;
11482             out_header = (void *)out_ext;
11483             break;
11484         }
11485         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
11486         {
11487             VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11488             const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header;
11489             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
11490             out_ext->pNext = NULL;
11491             out_ext->micromap = in_ext->micromap;
11492             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
11493             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
11494             out_header->pNext = (void *)out_ext;
11495             out_header = (void *)out_ext;
11496             break;
11497         }
11498         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
11499         {
11500             VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11501             const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header;
11502             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
11503             out_ext->pNext = NULL;
11504             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
11505             out_header->pNext = (void *)out_ext;
11506             out_header = (void *)out_ext;
11507             break;
11508         }
11509         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
11510         {
11511             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11512             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *)in_header;
11513             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
11514             out_ext->pNext = NULL;
11515             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
11516             out_header->pNext = (void *)out_ext;
11517             out_header = (void *)out_ext;
11518             break;
11519         }
11520         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
11521         {
11522             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11523             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header;
11524             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
11525             out_ext->pNext = NULL;
11526             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
11527             out_header->pNext = (void *)out_ext;
11528             out_header = (void *)out_ext;
11529             break;
11530         }
11531         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
11532         {
11533             VkPhysicalDevicePipelineRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11534             const VkPhysicalDevicePipelineRobustnessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT *)in_header;
11535             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
11536             out_ext->pNext = NULL;
11537             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
11538             out_header->pNext = (void *)out_ext;
11539             out_header = (void *)out_ext;
11540             break;
11541         }
11542         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
11543         {
11544             VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11545             const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header;
11546             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
11547             out_ext->pNext = NULL;
11548             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
11549             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
11550             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
11551             out_header->pNext = (void *)out_ext;
11552             out_header = (void *)out_ext;
11553             break;
11554         }
11555         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
11556         {
11557             VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11558             const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header;
11559             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
11560             out_ext->pNext = NULL;
11561             out_ext->tileProperties = in_ext->tileProperties;
11562             out_header->pNext = (void *)out_ext;
11563             out_header = (void *)out_ext;
11564             break;
11565         }
11566         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
11567         {
11568             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11569             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header;
11570             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
11571             out_ext->pNext = NULL;
11572             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
11573             out_header->pNext = (void *)out_ext;
11574             out_header = (void *)out_ext;
11575             break;
11576         }
11577         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
11578         {
11579             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11580             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *)in_header;
11581             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
11582             out_ext->pNext = NULL;
11583             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
11584             out_header->pNext = (void *)out_ext;
11585             out_header = (void *)out_ext;
11586             break;
11587         }
11588         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
11589         {
11590             VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11591             const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header;
11592             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
11593             out_ext->pNext = NULL;
11594             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
11595             out_header->pNext = (void *)out_ext;
11596             out_header = (void *)out_ext;
11597             break;
11598         }
11599         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
11600         {
11601             VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11602             const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header;
11603             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
11604             out_ext->pNext = NULL;
11605             out_ext->opticalFlow = in_ext->opticalFlow;
11606             out_header->pNext = (void *)out_ext;
11607             out_header = (void *)out_ext;
11608             break;
11609         }
11610         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
11611         {
11612             VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11613             const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header;
11614             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
11615             out_ext->pNext = NULL;
11616             out_ext->deviceFault = in_ext->deviceFault;
11617             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
11618             out_header->pNext = (void *)out_ext;
11619             out_header = (void *)out_ext;
11620             break;
11621         }
11622         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
11623         {
11624             VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11625             const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *)in_header;
11626             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
11627             out_ext->pNext = NULL;
11628             out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
11629             out_header->pNext = (void *)out_ext;
11630             out_header = (void *)out_ext;
11631             break;
11632         }
11633         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
11634         {
11635             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11636             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header;
11637             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
11638             out_ext->pNext = NULL;
11639             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
11640             out_header->pNext = (void *)out_ext;
11641             out_header = (void *)out_ext;
11642             break;
11643         }
11644         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
11645         {
11646             VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11647             const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *)in_header;
11648             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT;
11649             out_ext->pNext = NULL;
11650             out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
11651             out_header->pNext = (void *)out_ext;
11652             out_header = (void *)out_ext;
11653             break;
11654         }
11655         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
11656         {
11657             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11658             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header;
11659             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
11660             out_ext->pNext = NULL;
11661             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
11662             out_header->pNext = (void *)out_ext;
11663             out_header = (void *)out_ext;
11664             break;
11665         }
11666         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
11667         {
11668             VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11669             const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *)in_header;
11670             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
11671             out_ext->pNext = NULL;
11672             out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
11673             out_header->pNext = (void *)out_ext;
11674             out_header = (void *)out_ext;
11675             break;
11676         }
11677         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
11678         {
11679             VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11680             const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *)in_header;
11681             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
11682             out_ext->pNext = NULL;
11683             out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
11684             out_header->pNext = (void *)out_ext;
11685             out_header = (void *)out_ext;
11686             break;
11687         }
11688         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
11689         {
11690             VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11691             const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *)in_header;
11692             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
11693             out_ext->pNext = NULL;
11694             out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
11695             out_header->pNext = (void *)out_ext;
11696             out_header = (void *)out_ext;
11697             break;
11698         }
11699         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
11700         {
11701             VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11702             const VkPhysicalDeviceShaderObjectFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT *)in_header;
11703             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
11704             out_ext->pNext = NULL;
11705             out_ext->shaderObject = in_ext->shaderObject;
11706             out_header->pNext = (void *)out_ext;
11707             out_header = (void *)out_ext;
11708             break;
11709         }
11710         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
11711         {
11712             VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11713             const VkPhysicalDeviceShaderTileImageFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT *)in_header;
11714             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
11715             out_ext->pNext = NULL;
11716             out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess;
11717             out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess;
11718             out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess;
11719             out_header->pNext = (void *)out_ext;
11720             out_header = (void *)out_ext;
11721             break;
11722         }
11723         default:
11724             FIXME("Unhandled sType %u.\n", in_header->sType);
11725             break;
11726         }
11727     }
11728 }
11729 #endif /* _WIN64 */
11730
11731 static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo32 *in, VkDeviceCreateInfo *out)
11732 {
11733     const VkBaseInStructure32 *in_header;
11734     VkBaseOutStructure *out_header = (void *)out;
11735
11736     if (!in) return;
11737
11738     out->sType = in->sType;
11739     out->pNext = NULL;
11740     out->flags = in->flags;
11741     out->queueCreateInfoCount = in->queueCreateInfoCount;
11742     out->pQueueCreateInfos = convert_VkDeviceQueueCreateInfo_array_win32_to_host(ctx, (const VkDeviceQueueCreateInfo32 *)UlongToPtr(in->pQueueCreateInfos), in->queueCreateInfoCount);
11743     out->enabledLayerCount = in->enabledLayerCount;
11744     out->ppEnabledLayerNames = convert_char_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppEnabledLayerNames), in->enabledLayerCount);
11745     out->enabledExtensionCount = in->enabledExtensionCount;
11746     out->ppEnabledExtensionNames = convert_char_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppEnabledExtensionNames), in->enabledExtensionCount);
11747     out->pEnabledFeatures = (const VkPhysicalDeviceFeatures *)UlongToPtr(in->pEnabledFeatures);
11748
11749     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
11750     {
11751         switch (in_header->sType)
11752         {
11753         case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
11754             break;
11755         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
11756         {
11757             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11758             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *)in_header;
11759             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
11760             out_ext->pNext = NULL;
11761             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
11762             out_header->pNext = (void *)out_ext;
11763             out_header = (void *)out_ext;
11764             break;
11765         }
11766         case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
11767         {
11768             VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11769             const VkDevicePrivateDataCreateInfo32 *in_ext = (const VkDevicePrivateDataCreateInfo32 *)in_header;
11770             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
11771             out_ext->pNext = NULL;
11772             out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount;
11773             out_header->pNext = (void *)out_ext;
11774             out_header = (void *)out_ext;
11775             break;
11776         }
11777         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
11778         {
11779             VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11780             const VkPhysicalDevicePrivateDataFeatures32 *in_ext = (const VkPhysicalDevicePrivateDataFeatures32 *)in_header;
11781             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
11782             out_ext->pNext = NULL;
11783             out_ext->privateData = in_ext->privateData;
11784             out_header->pNext = (void *)out_ext;
11785             out_header = (void *)out_ext;
11786             break;
11787         }
11788         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
11789         {
11790             VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11791             const VkPhysicalDeviceFeatures232 *in_ext = (const VkPhysicalDeviceFeatures232 *)in_header;
11792             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
11793             out_ext->pNext = NULL;
11794             out_ext->features = in_ext->features;
11795             out_header->pNext = (void *)out_ext;
11796             out_header = (void *)out_ext;
11797             break;
11798         }
11799         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
11800         {
11801             VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11802             const VkPhysicalDeviceVariablePointersFeatures32 *in_ext = (const VkPhysicalDeviceVariablePointersFeatures32 *)in_header;
11803             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
11804             out_ext->pNext = NULL;
11805             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
11806             out_ext->variablePointers = in_ext->variablePointers;
11807             out_header->pNext = (void *)out_ext;
11808             out_header = (void *)out_ext;
11809             break;
11810         }
11811         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
11812         {
11813             VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11814             const VkPhysicalDeviceMultiviewFeatures32 *in_ext = (const VkPhysicalDeviceMultiviewFeatures32 *)in_header;
11815             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
11816             out_ext->pNext = NULL;
11817             out_ext->multiview = in_ext->multiview;
11818             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
11819             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
11820             out_header->pNext = (void *)out_ext;
11821             out_header = (void *)out_ext;
11822             break;
11823         }
11824         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
11825         {
11826             VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11827             const VkDeviceGroupDeviceCreateInfo32 *in_ext = (const VkDeviceGroupDeviceCreateInfo32 *)in_header;
11828             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
11829             out_ext->pNext = NULL;
11830             out_ext->physicalDeviceCount = in_ext->physicalDeviceCount;
11831             out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in_ext->pPhysicalDevices), in_ext->physicalDeviceCount);
11832             out_header->pNext = (void *)out_ext;
11833             out_header = (void *)out_ext;
11834             break;
11835         }
11836         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
11837         {
11838             VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11839             const VkPhysicalDevicePresentIdFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR32 *)in_header;
11840             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
11841             out_ext->pNext = NULL;
11842             out_ext->presentId = in_ext->presentId;
11843             out_header->pNext = (void *)out_ext;
11844             out_header = (void *)out_ext;
11845             break;
11846         }
11847         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
11848         {
11849             VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11850             const VkPhysicalDevicePresentWaitFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR32 *)in_header;
11851             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
11852             out_ext->pNext = NULL;
11853             out_ext->presentWait = in_ext->presentWait;
11854             out_header->pNext = (void *)out_ext;
11855             out_header = (void *)out_ext;
11856             break;
11857         }
11858         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
11859         {
11860             VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11861             const VkPhysicalDevice16BitStorageFeatures32 *in_ext = (const VkPhysicalDevice16BitStorageFeatures32 *)in_header;
11862             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
11863             out_ext->pNext = NULL;
11864             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
11865             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
11866             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
11867             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
11868             out_header->pNext = (void *)out_ext;
11869             out_header = (void *)out_ext;
11870             break;
11871         }
11872         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
11873         {
11874             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11875             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *)in_header;
11876             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
11877             out_ext->pNext = NULL;
11878             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
11879             out_header->pNext = (void *)out_ext;
11880             out_header = (void *)out_ext;
11881             break;
11882         }
11883         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
11884         {
11885             VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11886             const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *)in_header;
11887             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
11888             out_ext->pNext = NULL;
11889             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
11890             out_header->pNext = (void *)out_ext;
11891             out_header = (void *)out_ext;
11892             break;
11893         }
11894         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
11895         {
11896             VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11897             const VkPhysicalDeviceProtectedMemoryFeatures32 *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures32 *)in_header;
11898             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
11899             out_ext->pNext = NULL;
11900             out_ext->protectedMemory = in_ext->protectedMemory;
11901             out_header->pNext = (void *)out_ext;
11902             out_header = (void *)out_ext;
11903             break;
11904         }
11905         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
11906         {
11907             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11908             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *)in_header;
11909             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
11910             out_ext->pNext = NULL;
11911             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
11912             out_header->pNext = (void *)out_ext;
11913             out_header = (void *)out_ext;
11914             break;
11915         }
11916         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
11917         {
11918             VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11919             const VkPhysicalDeviceMultiDrawFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT32 *)in_header;
11920             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
11921             out_ext->pNext = NULL;
11922             out_ext->multiDraw = in_ext->multiDraw;
11923             out_header->pNext = (void *)out_ext;
11924             out_header = (void *)out_ext;
11925             break;
11926         }
11927         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
11928         {
11929             VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11930             const VkPhysicalDeviceInlineUniformBlockFeatures32 *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures32 *)in_header;
11931             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
11932             out_ext->pNext = NULL;
11933             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
11934             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
11935             out_header->pNext = (void *)out_ext;
11936             out_header = (void *)out_ext;
11937             break;
11938         }
11939         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
11940         {
11941             VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11942             const VkPhysicalDeviceMaintenance4Features32 *in_ext = (const VkPhysicalDeviceMaintenance4Features32 *)in_header;
11943             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
11944             out_ext->pNext = NULL;
11945             out_ext->maintenance4 = in_ext->maintenance4;
11946             out_header->pNext = (void *)out_ext;
11947             out_header = (void *)out_ext;
11948             break;
11949         }
11950         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
11951         {
11952             VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11953             const VkPhysicalDeviceShaderDrawParametersFeatures32 *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures32 *)in_header;
11954             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
11955             out_ext->pNext = NULL;
11956             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
11957             out_header->pNext = (void *)out_ext;
11958             out_header = (void *)out_ext;
11959             break;
11960         }
11961         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
11962         {
11963             VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11964             const VkPhysicalDeviceShaderFloat16Int8Features32 *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features32 *)in_header;
11965             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
11966             out_ext->pNext = NULL;
11967             out_ext->shaderFloat16 = in_ext->shaderFloat16;
11968             out_ext->shaderInt8 = in_ext->shaderInt8;
11969             out_header->pNext = (void *)out_ext;
11970             out_header = (void *)out_ext;
11971             break;
11972         }
11973         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
11974         {
11975             VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11976             const VkPhysicalDeviceHostQueryResetFeatures32 *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures32 *)in_header;
11977             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
11978             out_ext->pNext = NULL;
11979             out_ext->hostQueryReset = in_ext->hostQueryReset;
11980             out_header->pNext = (void *)out_ext;
11981             out_header = (void *)out_ext;
11982             break;
11983         }
11984         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
11985         {
11986             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11987             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *)in_header;
11988             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
11989             out_ext->pNext = NULL;
11990             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
11991             out_header->pNext = (void *)out_ext;
11992             out_header = (void *)out_ext;
11993             break;
11994         }
11995         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
11996         {
11997             VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11998             const VkPhysicalDeviceDescriptorIndexingFeatures32 *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures32 *)in_header;
11999             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
12000             out_ext->pNext = NULL;
12001             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
12002             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
12003             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
12004             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
12005             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
12006             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
12007             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
12008             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
12009             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
12010             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
12011             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
12012             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
12013             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
12014             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
12015             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
12016             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
12017             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
12018             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
12019             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
12020             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
12021             out_header->pNext = (void *)out_ext;
12022             out_header = (void *)out_ext;
12023             break;
12024         }
12025         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
12026         {
12027             VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12028             const VkPhysicalDeviceTimelineSemaphoreFeatures32 *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures32 *)in_header;
12029             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
12030             out_ext->pNext = NULL;
12031             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
12032             out_header->pNext = (void *)out_ext;
12033             out_header = (void *)out_ext;
12034             break;
12035         }
12036         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
12037         {
12038             VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12039             const VkPhysicalDevice8BitStorageFeatures32 *in_ext = (const VkPhysicalDevice8BitStorageFeatures32 *)in_header;
12040             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
12041             out_ext->pNext = NULL;
12042             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
12043             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
12044             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
12045             out_header->pNext = (void *)out_ext;
12046             out_header = (void *)out_ext;
12047             break;
12048         }
12049         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
12050         {
12051             VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12052             const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *)in_header;
12053             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
12054             out_ext->pNext = NULL;
12055             out_ext->conditionalRendering = in_ext->conditionalRendering;
12056             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
12057             out_header->pNext = (void *)out_ext;
12058             out_header = (void *)out_ext;
12059             break;
12060         }
12061         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
12062         {
12063             VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12064             const VkPhysicalDeviceVulkanMemoryModelFeatures32 *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures32 *)in_header;
12065             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
12066             out_ext->pNext = NULL;
12067             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
12068             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
12069             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
12070             out_header->pNext = (void *)out_ext;
12071             out_header = (void *)out_ext;
12072             break;
12073         }
12074         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
12075         {
12076             VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12077             const VkPhysicalDeviceShaderAtomicInt64Features32 *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features32 *)in_header;
12078             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
12079             out_ext->pNext = NULL;
12080             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
12081             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
12082             out_header->pNext = (void *)out_ext;
12083             out_header = (void *)out_ext;
12084             break;
12085         }
12086         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
12087         {
12088             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12089             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *)in_header;
12090             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
12091             out_ext->pNext = NULL;
12092             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
12093             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
12094             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
12095             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
12096             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
12097             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
12098             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
12099             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
12100             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
12101             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
12102             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
12103             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
12104             out_header->pNext = (void *)out_ext;
12105             out_header = (void *)out_ext;
12106             break;
12107         }
12108         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
12109         {
12110             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12111             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *)in_header;
12112             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
12113             out_ext->pNext = NULL;
12114             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
12115             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
12116             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
12117             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
12118             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
12119             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
12120             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
12121             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
12122             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
12123             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
12124             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
12125             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
12126             out_header->pNext = (void *)out_ext;
12127             out_header = (void *)out_ext;
12128             break;
12129         }
12130         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
12131         {
12132             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12133             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *)in_header;
12134             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
12135             out_ext->pNext = NULL;
12136             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
12137             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
12138             out_header->pNext = (void *)out_ext;
12139             out_header = (void *)out_ext;
12140             break;
12141         }
12142         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
12143         {
12144             VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12145             const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *)in_header;
12146             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
12147             out_ext->pNext = NULL;
12148             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
12149             out_header->pNext = (void *)out_ext;
12150             out_header = (void *)out_ext;
12151             break;
12152         }
12153         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
12154         {
12155             VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12156             const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *)in_header;
12157             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
12158             out_ext->pNext = NULL;
12159             out_ext->transformFeedback = in_ext->transformFeedback;
12160             out_ext->geometryStreams = in_ext->geometryStreams;
12161             out_header->pNext = (void *)out_ext;
12162             out_header = (void *)out_ext;
12163             break;
12164         }
12165         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
12166         {
12167             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12168             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *)in_header;
12169             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
12170             out_ext->pNext = NULL;
12171             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
12172             out_header->pNext = (void *)out_ext;
12173             out_header = (void *)out_ext;
12174             break;
12175         }
12176         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
12177         {
12178             VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12179             const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *)in_header;
12180             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
12181             out_ext->pNext = NULL;
12182             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
12183             out_header->pNext = (void *)out_ext;
12184             out_header = (void *)out_ext;
12185             break;
12186         }
12187         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
12188         {
12189             VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12190             const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *)in_header;
12191             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
12192             out_ext->pNext = NULL;
12193             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
12194             out_header->pNext = (void *)out_ext;
12195             out_header = (void *)out_ext;
12196             break;
12197         }
12198         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
12199         {
12200             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12201             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *)in_header;
12202             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
12203             out_ext->pNext = NULL;
12204             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
12205             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
12206             out_header->pNext = (void *)out_ext;
12207             out_header = (void *)out_ext;
12208             break;
12209         }
12210         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
12211         {
12212             VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12213             const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *)in_header;
12214             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
12215             out_ext->pNext = NULL;
12216             out_ext->imageFootprint = in_ext->imageFootprint;
12217             out_header->pNext = (void *)out_ext;
12218             out_header = (void *)out_ext;
12219             break;
12220         }
12221         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
12222         {
12223             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12224             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *)in_header;
12225             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
12226             out_ext->pNext = NULL;
12227             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
12228             out_header->pNext = (void *)out_ext;
12229             out_header = (void *)out_ext;
12230             break;
12231         }
12232         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
12233         {
12234             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12235             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *)in_header;
12236             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
12237             out_ext->pNext = NULL;
12238             out_ext->indirectCopy = in_ext->indirectCopy;
12239             out_header->pNext = (void *)out_ext;
12240             out_header = (void *)out_ext;
12241             break;
12242         }
12243         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
12244         {
12245             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12246             const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *)in_header;
12247             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
12248             out_ext->pNext = NULL;
12249             out_ext->memoryDecompression = in_ext->memoryDecompression;
12250             out_header->pNext = (void *)out_ext;
12251             out_header = (void *)out_ext;
12252             break;
12253         }
12254         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
12255         {
12256             VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12257             const VkPhysicalDeviceShadingRateImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV32 *)in_header;
12258             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
12259             out_ext->pNext = NULL;
12260             out_ext->shadingRateImage = in_ext->shadingRateImage;
12261             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
12262             out_header->pNext = (void *)out_ext;
12263             out_header = (void *)out_ext;
12264             break;
12265         }
12266         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
12267         {
12268             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12269             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *)in_header;
12270             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
12271             out_ext->pNext = NULL;
12272             out_ext->invocationMask = in_ext->invocationMask;
12273             out_header->pNext = (void *)out_ext;
12274             out_header = (void *)out_ext;
12275             break;
12276         }
12277         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
12278         {
12279             VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12280             const VkPhysicalDeviceMeshShaderFeaturesNV32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV32 *)in_header;
12281             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
12282             out_ext->pNext = NULL;
12283             out_ext->taskShader = in_ext->taskShader;
12284             out_ext->meshShader = in_ext->meshShader;
12285             out_header->pNext = (void *)out_ext;
12286             out_header = (void *)out_ext;
12287             break;
12288         }
12289         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
12290         {
12291             VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12292             const VkPhysicalDeviceMeshShaderFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT32 *)in_header;
12293             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
12294             out_ext->pNext = NULL;
12295             out_ext->taskShader = in_ext->taskShader;
12296             out_ext->meshShader = in_ext->meshShader;
12297             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
12298             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
12299             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
12300             out_header->pNext = (void *)out_ext;
12301             out_header = (void *)out_ext;
12302             break;
12303         }
12304         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
12305         {
12306             VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12307             const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *)in_header;
12308             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
12309             out_ext->pNext = NULL;
12310             out_ext->accelerationStructure = in_ext->accelerationStructure;
12311             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
12312             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
12313             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
12314             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
12315             out_header->pNext = (void *)out_ext;
12316             out_header = (void *)out_ext;
12317             break;
12318         }
12319         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
12320         {
12321             VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12322             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *)in_header;
12323             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
12324             out_ext->pNext = NULL;
12325             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
12326             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
12327             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
12328             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
12329             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
12330             out_header->pNext = (void *)out_ext;
12331             out_header = (void *)out_ext;
12332             break;
12333         }
12334         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
12335         {
12336             VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12337             const VkPhysicalDeviceRayQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR32 *)in_header;
12338             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
12339             out_ext->pNext = NULL;
12340             out_ext->rayQuery = in_ext->rayQuery;
12341             out_header->pNext = (void *)out_ext;
12342             out_header = (void *)out_ext;
12343             break;
12344         }
12345         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
12346         {
12347             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12348             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *)in_header;
12349             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
12350             out_ext->pNext = NULL;
12351             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
12352             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
12353             out_header->pNext = (void *)out_ext;
12354             out_header = (void *)out_ext;
12355             break;
12356         }
12357         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
12358         {
12359             VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12360             const VkDeviceMemoryOverallocationCreateInfoAMD32 *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD32 *)in_header;
12361             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD;
12362             out_ext->pNext = NULL;
12363             out_ext->overallocationBehavior = in_ext->overallocationBehavior;
12364             out_header->pNext = (void *)out_ext;
12365             out_header = (void *)out_ext;
12366             break;
12367         }
12368         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
12369         {
12370             VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12371             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *)in_header;
12372             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
12373             out_ext->pNext = NULL;
12374             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
12375             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
12376             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
12377             out_header->pNext = (void *)out_ext;
12378             out_header = (void *)out_ext;
12379             break;
12380         }
12381         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
12382         {
12383             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12384             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *)in_header;
12385             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
12386             out_ext->pNext = NULL;
12387             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
12388             out_header->pNext = (void *)out_ext;
12389             out_header = (void *)out_ext;
12390             break;
12391         }
12392         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
12393         {
12394             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12395             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *)in_header;
12396             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
12397             out_ext->pNext = NULL;
12398             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
12399             out_header->pNext = (void *)out_ext;
12400             out_header = (void *)out_ext;
12401             break;
12402         }
12403         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
12404         {
12405             VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12406             const VkPhysicalDeviceScalarBlockLayoutFeatures32 *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures32 *)in_header;
12407             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
12408             out_ext->pNext = NULL;
12409             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
12410             out_header->pNext = (void *)out_ext;
12411             out_header = (void *)out_ext;
12412             break;
12413         }
12414         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
12415         {
12416             VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12417             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *)in_header;
12418             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
12419             out_ext->pNext = NULL;
12420             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
12421             out_header->pNext = (void *)out_ext;
12422             out_header = (void *)out_ext;
12423             break;
12424         }
12425         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
12426         {
12427             VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12428             const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *)in_header;
12429             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
12430             out_ext->pNext = NULL;
12431             out_ext->depthClipEnable = in_ext->depthClipEnable;
12432             out_header->pNext = (void *)out_ext;
12433             out_header = (void *)out_ext;
12434             break;
12435         }
12436         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
12437         {
12438             VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12439             const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *)in_header;
12440             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
12441             out_ext->pNext = NULL;
12442             out_ext->memoryPriority = in_ext->memoryPriority;
12443             out_header->pNext = (void *)out_ext;
12444             out_header = (void *)out_ext;
12445             break;
12446         }
12447         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
12448         {
12449             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12450             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *)in_header;
12451             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
12452             out_ext->pNext = NULL;
12453             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
12454             out_header->pNext = (void *)out_ext;
12455             out_header = (void *)out_ext;
12456             break;
12457         }
12458         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
12459         {
12460             VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12461             const VkPhysicalDeviceBufferDeviceAddressFeatures32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures32 *)in_header;
12462             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
12463             out_ext->pNext = NULL;
12464             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
12465             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
12466             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
12467             out_header->pNext = (void *)out_ext;
12468             out_header = (void *)out_ext;
12469             break;
12470         }
12471         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
12472         {
12473             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12474             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *)in_header;
12475             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
12476             out_ext->pNext = NULL;
12477             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
12478             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
12479             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
12480             out_header->pNext = (void *)out_ext;
12481             out_header = (void *)out_ext;
12482             break;
12483         }
12484         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
12485         {
12486             VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12487             const VkPhysicalDeviceImagelessFramebufferFeatures32 *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures32 *)in_header;
12488             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
12489             out_ext->pNext = NULL;
12490             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
12491             out_header->pNext = (void *)out_ext;
12492             out_header = (void *)out_ext;
12493             break;
12494         }
12495         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
12496         {
12497             VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12498             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *)in_header;
12499             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
12500             out_ext->pNext = NULL;
12501             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
12502             out_header->pNext = (void *)out_ext;
12503             out_header = (void *)out_ext;
12504             break;
12505         }
12506         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
12507         {
12508             VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12509             const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *)in_header;
12510             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
12511             out_ext->pNext = NULL;
12512             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
12513             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
12514             out_header->pNext = (void *)out_ext;
12515             out_header = (void *)out_ext;
12516             break;
12517         }
12518         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
12519         {
12520             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12521             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *)in_header;
12522             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
12523             out_ext->pNext = NULL;
12524             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
12525             out_header->pNext = (void *)out_ext;
12526             out_header = (void *)out_ext;
12527             break;
12528         }
12529         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
12530         {
12531             VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12532             const VkPhysicalDevicePresentBarrierFeaturesNV32 *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV32 *)in_header;
12533             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
12534             out_ext->pNext = NULL;
12535             out_ext->presentBarrier = in_ext->presentBarrier;
12536             out_header->pNext = (void *)out_ext;
12537             out_header = (void *)out_ext;
12538             break;
12539         }
12540         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
12541         {
12542             VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12543             const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *)in_header;
12544             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
12545             out_ext->pNext = NULL;
12546             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
12547             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
12548             out_header->pNext = (void *)out_ext;
12549             out_header = (void *)out_ext;
12550             break;
12551         }
12552         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
12553         {
12554             VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12555             const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *)in_header;
12556             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
12557             out_ext->pNext = NULL;
12558             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
12559             out_header->pNext = (void *)out_ext;
12560             out_header = (void *)out_ext;
12561             break;
12562         }
12563         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
12564         {
12565             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12566             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *)in_header;
12567             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
12568             out_ext->pNext = NULL;
12569             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
12570             out_header->pNext = (void *)out_ext;
12571             out_header = (void *)out_ext;
12572             break;
12573         }
12574         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
12575         {
12576             VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12577             const VkPhysicalDeviceShaderClockFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR32 *)in_header;
12578             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
12579             out_ext->pNext = NULL;
12580             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
12581             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
12582             out_header->pNext = (void *)out_ext;
12583             out_header = (void *)out_ext;
12584             break;
12585         }
12586         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
12587         {
12588             VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12589             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *)in_header;
12590             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
12591             out_ext->pNext = NULL;
12592             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
12593             out_header->pNext = (void *)out_ext;
12594             out_header = (void *)out_ext;
12595             break;
12596         }
12597         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
12598         {
12599             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12600             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *)in_header;
12601             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
12602             out_ext->pNext = NULL;
12603             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
12604             out_header->pNext = (void *)out_ext;
12605             out_header = (void *)out_ext;
12606             break;
12607         }
12608         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
12609         {
12610             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12611             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *)in_header;
12612             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
12613             out_ext->pNext = NULL;
12614             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
12615             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
12616             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
12617             out_header->pNext = (void *)out_ext;
12618             out_header = (void *)out_ext;
12619             break;
12620         }
12621         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
12622         {
12623             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12624             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *)in_header;
12625             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
12626             out_ext->pNext = NULL;
12627             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
12628             out_header->pNext = (void *)out_ext;
12629             out_header = (void *)out_ext;
12630             break;
12631         }
12632         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
12633         {
12634             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12635             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *)in_header;
12636             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
12637             out_ext->pNext = NULL;
12638             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
12639             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
12640             out_header->pNext = (void *)out_ext;
12641             out_header = (void *)out_ext;
12642             break;
12643         }
12644         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
12645         {
12646             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12647             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *)in_header;
12648             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
12649             out_ext->pNext = NULL;
12650             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
12651             out_header->pNext = (void *)out_ext;
12652             out_header = (void *)out_ext;
12653             break;
12654         }
12655         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
12656         {
12657             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12658             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *)in_header;
12659             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
12660             out_ext->pNext = NULL;
12661             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
12662             out_header->pNext = (void *)out_ext;
12663             out_header = (void *)out_ext;
12664             break;
12665         }
12666         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
12667         {
12668             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12669             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *)in_header;
12670             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
12671             out_ext->pNext = NULL;
12672             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
12673             out_header->pNext = (void *)out_ext;
12674             out_header = (void *)out_ext;
12675             break;
12676         }
12677         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
12678         {
12679             VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12680             const VkPhysicalDeviceSubgroupSizeControlFeatures32 *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures32 *)in_header;
12681             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
12682             out_ext->pNext = NULL;
12683             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
12684             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
12685             out_header->pNext = (void *)out_ext;
12686             out_header = (void *)out_ext;
12687             break;
12688         }
12689         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
12690         {
12691             VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12692             const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *)in_header;
12693             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
12694             out_ext->pNext = NULL;
12695             out_ext->rectangularLines = in_ext->rectangularLines;
12696             out_ext->bresenhamLines = in_ext->bresenhamLines;
12697             out_ext->smoothLines = in_ext->smoothLines;
12698             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
12699             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
12700             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
12701             out_header->pNext = (void *)out_ext;
12702             out_header = (void *)out_ext;
12703             break;
12704         }
12705         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
12706         {
12707             VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12708             const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *)in_header;
12709             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
12710             out_ext->pNext = NULL;
12711             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
12712             out_header->pNext = (void *)out_ext;
12713             out_header = (void *)out_ext;
12714             break;
12715         }
12716         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
12717         {
12718             VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12719             const VkPhysicalDeviceVulkan11Features32 *in_ext = (const VkPhysicalDeviceVulkan11Features32 *)in_header;
12720             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
12721             out_ext->pNext = NULL;
12722             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
12723             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
12724             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
12725             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
12726             out_ext->multiview = in_ext->multiview;
12727             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
12728             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
12729             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
12730             out_ext->variablePointers = in_ext->variablePointers;
12731             out_ext->protectedMemory = in_ext->protectedMemory;
12732             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
12733             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
12734             out_header->pNext = (void *)out_ext;
12735             out_header = (void *)out_ext;
12736             break;
12737         }
12738         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
12739         {
12740             VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12741             const VkPhysicalDeviceVulkan12Features32 *in_ext = (const VkPhysicalDeviceVulkan12Features32 *)in_header;
12742             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
12743             out_ext->pNext = NULL;
12744             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
12745             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
12746             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
12747             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
12748             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
12749             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
12750             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
12751             out_ext->shaderFloat16 = in_ext->shaderFloat16;
12752             out_ext->shaderInt8 = in_ext->shaderInt8;
12753             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
12754             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
12755             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
12756             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
12757             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
12758             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
12759             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
12760             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
12761             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
12762             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
12763             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
12764             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
12765             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
12766             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
12767             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
12768             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
12769             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
12770             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
12771             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
12772             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
12773             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
12774             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
12775             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
12776             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
12777             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
12778             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
12779             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
12780             out_ext->hostQueryReset = in_ext->hostQueryReset;
12781             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
12782             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
12783             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
12784             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
12785             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
12786             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
12787             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
12788             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
12789             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
12790             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
12791             out_header->pNext = (void *)out_ext;
12792             out_header = (void *)out_ext;
12793             break;
12794         }
12795         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
12796         {
12797             VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12798             const VkPhysicalDeviceVulkan13Features32 *in_ext = (const VkPhysicalDeviceVulkan13Features32 *)in_header;
12799             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
12800             out_ext->pNext = NULL;
12801             out_ext->robustImageAccess = in_ext->robustImageAccess;
12802             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
12803             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
12804             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
12805             out_ext->privateData = in_ext->privateData;
12806             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
12807             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
12808             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
12809             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
12810             out_ext->synchronization2 = in_ext->synchronization2;
12811             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
12812             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
12813             out_ext->dynamicRendering = in_ext->dynamicRendering;
12814             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
12815             out_ext->maintenance4 = in_ext->maintenance4;
12816             out_header->pNext = (void *)out_ext;
12817             out_header = (void *)out_ext;
12818             break;
12819         }
12820         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
12821         {
12822             VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12823             const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *)in_header;
12824             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
12825             out_ext->pNext = NULL;
12826             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
12827             out_header->pNext = (void *)out_ext;
12828             out_header = (void *)out_ext;
12829             break;
12830         }
12831         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
12832         {
12833             VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12834             const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *)in_header;
12835             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
12836             out_ext->pNext = NULL;
12837             out_ext->customBorderColors = in_ext->customBorderColors;
12838             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
12839             out_header->pNext = (void *)out_ext;
12840             out_header = (void *)out_ext;
12841             break;
12842         }
12843         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
12844         {
12845             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12846             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *)in_header;
12847             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
12848             out_ext->pNext = NULL;
12849             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
12850             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
12851             out_header->pNext = (void *)out_ext;
12852             out_header = (void *)out_ext;
12853             break;
12854         }
12855         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
12856         {
12857             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12858             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *)in_header;
12859             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
12860             out_ext->pNext = NULL;
12861             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
12862             out_header->pNext = (void *)out_ext;
12863             out_header = (void *)out_ext;
12864             break;
12865         }
12866         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
12867         {
12868             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12869             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *)in_header;
12870             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
12871             out_ext->pNext = NULL;
12872             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
12873             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
12874             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
12875             out_header->pNext = (void *)out_ext;
12876             out_header = (void *)out_ext;
12877             break;
12878         }
12879         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
12880         {
12881             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12882             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *)in_header;
12883             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
12884             out_ext->pNext = NULL;
12885             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
12886             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
12887             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
12888             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
12889             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
12890             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
12891             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
12892             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
12893             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
12894             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
12895             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
12896             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
12897             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
12898             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
12899             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
12900             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
12901             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
12902             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
12903             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
12904             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
12905             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
12906             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
12907             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
12908             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
12909             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
12910             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
12911             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
12912             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
12913             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
12914             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
12915             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
12916             out_header->pNext = (void *)out_ext;
12917             out_header = (void *)out_ext;
12918             break;
12919         }
12920         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
12921         {
12922             VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12923             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *)in_header;
12924             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
12925             out_ext->pNext = NULL;
12926             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
12927             out_header->pNext = (void *)out_ext;
12928             out_header = (void *)out_ext;
12929             break;
12930         }
12931         case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
12932         {
12933             VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12934             const VkDeviceDiagnosticsConfigCreateInfoNV32 *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV32 *)in_header;
12935             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
12936             out_ext->pNext = NULL;
12937             out_ext->flags = in_ext->flags;
12938             out_header->pNext = (void *)out_ext;
12939             out_header = (void *)out_ext;
12940             break;
12941         }
12942         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
12943         {
12944             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12945             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *)in_header;
12946             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
12947             out_ext->pNext = NULL;
12948             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
12949             out_header->pNext = (void *)out_ext;
12950             out_header = (void *)out_ext;
12951             break;
12952         }
12953         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
12954         {
12955             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12956             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *)in_header;
12957             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
12958             out_ext->pNext = NULL;
12959             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
12960             out_header->pNext = (void *)out_ext;
12961             out_header = (void *)out_ext;
12962             break;
12963         }
12964         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
12965         {
12966             VkPhysicalDeviceRobustness2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12967             const VkPhysicalDeviceRobustness2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT32 *)in_header;
12968             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
12969             out_ext->pNext = NULL;
12970             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
12971             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
12972             out_ext->nullDescriptor = in_ext->nullDescriptor;
12973             out_header->pNext = (void *)out_ext;
12974             out_header = (void *)out_ext;
12975             break;
12976         }
12977         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
12978         {
12979             VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12980             const VkPhysicalDeviceImageRobustnessFeatures32 *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures32 *)in_header;
12981             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
12982             out_ext->pNext = NULL;
12983             out_ext->robustImageAccess = in_ext->robustImageAccess;
12984             out_header->pNext = (void *)out_ext;
12985             out_header = (void *)out_ext;
12986             break;
12987         }
12988         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
12989         {
12990             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12991             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *)in_header;
12992             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
12993             out_ext->pNext = NULL;
12994             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
12995             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
12996             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
12997             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
12998             out_header->pNext = (void *)out_ext;
12999             out_header = (void *)out_ext;
13000             break;
13001         }
13002         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
13003         {
13004             VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13005             const VkPhysicalDevice4444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT32 *)in_header;
13006             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
13007             out_ext->pNext = NULL;
13008             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
13009             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
13010             out_header->pNext = (void *)out_ext;
13011             out_header = (void *)out_ext;
13012             break;
13013         }
13014         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
13015         {
13016             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13017             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *)in_header;
13018             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
13019             out_ext->pNext = NULL;
13020             out_ext->subpassShading = in_ext->subpassShading;
13021             out_header->pNext = (void *)out_ext;
13022             out_header = (void *)out_ext;
13023             break;
13024         }
13025         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
13026         {
13027             VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13028             const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *)in_header;
13029             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
13030             out_ext->pNext = NULL;
13031             out_ext->clustercullingShader = in_ext->clustercullingShader;
13032             out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
13033             out_header->pNext = (void *)out_ext;
13034             out_header = (void *)out_ext;
13035             break;
13036         }
13037         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
13038         {
13039             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13040             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *)in_header;
13041             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
13042             out_ext->pNext = NULL;
13043             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
13044             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
13045             out_header->pNext = (void *)out_ext;
13046             out_header = (void *)out_ext;
13047             break;
13048         }
13049         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
13050         {
13051             VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13052             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *)in_header;
13053             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
13054             out_ext->pNext = NULL;
13055             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
13056             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
13057             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
13058             out_header->pNext = (void *)out_ext;
13059             out_header = (void *)out_ext;
13060             break;
13061         }
13062         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
13063         {
13064             VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13065             const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *)in_header;
13066             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
13067             out_ext->pNext = NULL;
13068             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
13069             out_header->pNext = (void *)out_ext;
13070             out_header = (void *)out_ext;
13071             break;
13072         }
13073         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
13074         {
13075             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13076             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *)in_header;
13077             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
13078             out_ext->pNext = NULL;
13079             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
13080             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
13081             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
13082             out_header->pNext = (void *)out_ext;
13083             out_header = (void *)out_ext;
13084             break;
13085         }
13086         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
13087         {
13088             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13089             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *)in_header;
13090             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
13091             out_ext->pNext = NULL;
13092             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
13093             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
13094             out_header->pNext = (void *)out_ext;
13095             out_header = (void *)out_ext;
13096             break;
13097         }
13098         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
13099         {
13100             VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13101             const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *)in_header;
13102             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
13103             out_ext->pNext = NULL;
13104             out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
13105             out_header->pNext = (void *)out_ext;
13106             out_header = (void *)out_ext;
13107             break;
13108         }
13109         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
13110         {
13111             VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13112             const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *)in_header;
13113             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
13114             out_ext->pNext = NULL;
13115             out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
13116             out_header->pNext = (void *)out_ext;
13117             out_header = (void *)out_ext;
13118             break;
13119         }
13120         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
13121         {
13122             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13123             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *)in_header;
13124             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
13125             out_ext->pNext = NULL;
13126             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
13127             out_header->pNext = (void *)out_ext;
13128             out_header = (void *)out_ext;
13129             break;
13130         }
13131         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
13132         {
13133             VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13134             const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *)in_header;
13135             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
13136             out_ext->pNext = NULL;
13137             out_ext->depthClipControl = in_ext->depthClipControl;
13138             out_header->pNext = (void *)out_ext;
13139             out_header = (void *)out_ext;
13140             break;
13141         }
13142         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
13143         {
13144             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13145             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *)in_header;
13146             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
13147             out_ext->pNext = NULL;
13148             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
13149             out_header->pNext = (void *)out_ext;
13150             out_header = (void *)out_ext;
13151             break;
13152         }
13153         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
13154         {
13155             VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13156             const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *)in_header;
13157             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
13158             out_ext->pNext = NULL;
13159             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
13160             out_header->pNext = (void *)out_ext;
13161             out_header = (void *)out_ext;
13162             break;
13163         }
13164         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
13165         {
13166             VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13167             const VkPhysicalDeviceSynchronization2Features32 *in_ext = (const VkPhysicalDeviceSynchronization2Features32 *)in_header;
13168             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
13169             out_ext->pNext = NULL;
13170             out_ext->synchronization2 = in_ext->synchronization2;
13171             out_header->pNext = (void *)out_ext;
13172             out_header = (void *)out_ext;
13173             break;
13174         }
13175         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
13176         {
13177             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13178             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *)in_header;
13179             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
13180             out_ext->pNext = NULL;
13181             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
13182             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
13183             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
13184             out_header->pNext = (void *)out_ext;
13185             out_header = (void *)out_ext;
13186             break;
13187         }
13188         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
13189         {
13190             VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13191             const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *)in_header;
13192             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
13193             out_ext->pNext = NULL;
13194             out_ext->legacyDithering = in_ext->legacyDithering;
13195             out_header->pNext = (void *)out_ext;
13196             out_header = (void *)out_ext;
13197             break;
13198         }
13199         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
13200         {
13201             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13202             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *)in_header;
13203             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
13204             out_ext->pNext = NULL;
13205             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
13206             out_header->pNext = (void *)out_ext;
13207             out_header = (void *)out_ext;
13208             break;
13209         }
13210         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
13211         {
13212             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13213             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *)in_header;
13214             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
13215             out_ext->pNext = NULL;
13216             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
13217             out_header->pNext = (void *)out_ext;
13218             out_header = (void *)out_ext;
13219             break;
13220         }
13221         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
13222         {
13223             VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13224             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *)in_header;
13225             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
13226             out_ext->pNext = NULL;
13227             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
13228             out_header->pNext = (void *)out_ext;
13229             out_header = (void *)out_ext;
13230             break;
13231         }
13232         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
13233         {
13234             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13235             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *)in_header;
13236             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
13237             out_ext->pNext = NULL;
13238             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
13239             out_header->pNext = (void *)out_ext;
13240             out_header = (void *)out_ext;
13241             break;
13242         }
13243         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
13244         {
13245             VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13246             const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *)in_header;
13247             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
13248             out_ext->pNext = NULL;
13249             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
13250             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
13251             out_header->pNext = (void *)out_ext;
13252             out_header = (void *)out_ext;
13253             break;
13254         }
13255         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
13256         {
13257             VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13258             const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *)in_header;
13259             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
13260             out_ext->pNext = NULL;
13261             out_ext->descriptorBuffer = in_ext->descriptorBuffer;
13262             out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
13263             out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
13264             out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
13265             out_header->pNext = (void *)out_ext;
13266             out_header = (void *)out_ext;
13267             break;
13268         }
13269         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
13270         {
13271             VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13272             const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *)in_header;
13273             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
13274             out_ext->pNext = NULL;
13275             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
13276             out_header->pNext = (void *)out_ext;
13277             out_header = (void *)out_ext;
13278             break;
13279         }
13280         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
13281         {
13282             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13283             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *)in_header;
13284             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
13285             out_ext->pNext = NULL;
13286             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
13287             out_header->pNext = (void *)out_ext;
13288             out_header = (void *)out_ext;
13289             break;
13290         }
13291         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
13292         {
13293             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13294             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *)in_header;
13295             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
13296             out_ext->pNext = NULL;
13297             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
13298             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
13299             out_header->pNext = (void *)out_ext;
13300             out_header = (void *)out_ext;
13301             break;
13302         }
13303         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
13304         {
13305             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13306             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *)in_header;
13307             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
13308             out_ext->pNext = NULL;
13309             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
13310             out_header->pNext = (void *)out_ext;
13311             out_header = (void *)out_ext;
13312             break;
13313         }
13314         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
13315         {
13316             VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13317             const VkPhysicalDeviceDynamicRenderingFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures32 *)in_header;
13318             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
13319             out_ext->pNext = NULL;
13320             out_ext->dynamicRendering = in_ext->dynamicRendering;
13321             out_header->pNext = (void *)out_ext;
13322             out_header = (void *)out_ext;
13323             break;
13324         }
13325         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
13326         {
13327             VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13328             const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *)in_header;
13329             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
13330             out_ext->pNext = NULL;
13331             out_ext->minLod = in_ext->minLod;
13332             out_header->pNext = (void *)out_ext;
13333             out_header = (void *)out_ext;
13334             break;
13335         }
13336         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
13337         {
13338             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13339             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *)in_header;
13340             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
13341             out_ext->pNext = NULL;
13342             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
13343             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
13344             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
13345             out_header->pNext = (void *)out_ext;
13346             out_header = (void *)out_ext;
13347             break;
13348         }
13349         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
13350         {
13351             VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13352             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *)in_header;
13353             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
13354             out_ext->pNext = NULL;
13355             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
13356             out_header->pNext = (void *)out_ext;
13357             out_header = (void *)out_ext;
13358             break;
13359         }
13360         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
13361         {
13362             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13363             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *)in_header;
13364             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
13365             out_ext->pNext = NULL;
13366             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
13367             out_header->pNext = (void *)out_ext;
13368             out_header = (void *)out_ext;
13369             break;
13370         }
13371         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
13372         {
13373             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13374             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *)in_header;
13375             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
13376             out_ext->pNext = NULL;
13377             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
13378             out_header->pNext = (void *)out_ext;
13379             out_header = (void *)out_ext;
13380             break;
13381         }
13382         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
13383         {
13384             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13385             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *)in_header;
13386             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
13387             out_ext->pNext = NULL;
13388             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
13389             out_header->pNext = (void *)out_ext;
13390             out_header = (void *)out_ext;
13391             break;
13392         }
13393         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
13394         {
13395             VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13396             const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *)in_header;
13397             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
13398             out_ext->pNext = NULL;
13399             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
13400             out_header->pNext = (void *)out_ext;
13401             out_header = (void *)out_ext;
13402             break;
13403         }
13404         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
13405         {
13406             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13407             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *)in_header;
13408             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
13409             out_ext->pNext = NULL;
13410             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
13411             out_header->pNext = (void *)out_ext;
13412             out_header = (void *)out_ext;
13413             break;
13414         }
13415         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
13416         {
13417             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13418             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *)in_header;
13419             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
13420             out_ext->pNext = NULL;
13421             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
13422             out_header->pNext = (void *)out_ext;
13423             out_header = (void *)out_ext;
13424             break;
13425         }
13426         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
13427         {
13428             VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13429             const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *)in_header;
13430             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
13431             out_ext->pNext = NULL;
13432             out_ext->micromap = in_ext->micromap;
13433             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
13434             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
13435             out_header->pNext = (void *)out_ext;
13436             out_header = (void *)out_ext;
13437             break;
13438         }
13439         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
13440         {
13441             VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13442             const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *)in_header;
13443             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
13444             out_ext->pNext = NULL;
13445             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
13446             out_header->pNext = (void *)out_ext;
13447             out_header = (void *)out_ext;
13448             break;
13449         }
13450         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
13451         {
13452             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13453             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *)in_header;
13454             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
13455             out_ext->pNext = NULL;
13456             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
13457             out_header->pNext = (void *)out_ext;
13458             out_header = (void *)out_ext;
13459             break;
13460         }
13461         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
13462         {
13463             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13464             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *)in_header;
13465             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
13466             out_ext->pNext = NULL;
13467             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
13468             out_header->pNext = (void *)out_ext;
13469             out_header = (void *)out_ext;
13470             break;
13471         }
13472         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
13473         {
13474             VkPhysicalDevicePipelineRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13475             const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *)in_header;
13476             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
13477             out_ext->pNext = NULL;
13478             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
13479             out_header->pNext = (void *)out_ext;
13480             out_header = (void *)out_ext;
13481             break;
13482         }
13483         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
13484         {
13485             VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13486             const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *)in_header;
13487             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
13488             out_ext->pNext = NULL;
13489             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
13490             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
13491             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
13492             out_header->pNext = (void *)out_ext;
13493             out_header = (void *)out_ext;
13494             break;
13495         }
13496         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
13497         {
13498             VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13499             const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *)in_header;
13500             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
13501             out_ext->pNext = NULL;
13502             out_ext->tileProperties = in_ext->tileProperties;
13503             out_header->pNext = (void *)out_ext;
13504             out_header = (void *)out_ext;
13505             break;
13506         }
13507         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
13508         {
13509             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13510             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *)in_header;
13511             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
13512             out_ext->pNext = NULL;
13513             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
13514             out_header->pNext = (void *)out_ext;
13515             out_header = (void *)out_ext;
13516             break;
13517         }
13518         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
13519         {
13520             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13521             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *)in_header;
13522             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
13523             out_ext->pNext = NULL;
13524             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
13525             out_header->pNext = (void *)out_ext;
13526             out_header = (void *)out_ext;
13527             break;
13528         }
13529         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
13530         {
13531             VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13532             const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *)in_header;
13533             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
13534             out_ext->pNext = NULL;
13535             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
13536             out_header->pNext = (void *)out_ext;
13537             out_header = (void *)out_ext;
13538             break;
13539         }
13540         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
13541         {
13542             VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13543             const VkPhysicalDeviceOpticalFlowFeaturesNV32 *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV32 *)in_header;
13544             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
13545             out_ext->pNext = NULL;
13546             out_ext->opticalFlow = in_ext->opticalFlow;
13547             out_header->pNext = (void *)out_ext;
13548             out_header = (void *)out_ext;
13549             break;
13550         }
13551         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
13552         {
13553             VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13554             const VkPhysicalDeviceFaultFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT32 *)in_header;
13555             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
13556             out_ext->pNext = NULL;
13557             out_ext->deviceFault = in_ext->deviceFault;
13558             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
13559             out_header->pNext = (void *)out_ext;
13560             out_header = (void *)out_ext;
13561             break;
13562         }
13563         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
13564         {
13565             VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13566             const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *)in_header;
13567             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
13568             out_ext->pNext = NULL;
13569             out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
13570             out_header->pNext = (void *)out_ext;
13571             out_header = (void *)out_ext;
13572             break;
13573         }
13574         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
13575         {
13576             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13577             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *)in_header;
13578             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
13579             out_ext->pNext = NULL;
13580             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
13581             out_header->pNext = (void *)out_ext;
13582             out_header = (void *)out_ext;
13583             break;
13584         }
13585         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
13586         {
13587             VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13588             const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *)in_header;
13589             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT;
13590             out_ext->pNext = NULL;
13591             out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
13592             out_header->pNext = (void *)out_ext;
13593             out_header = (void *)out_ext;
13594             break;
13595         }
13596         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
13597         {
13598             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13599             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *)in_header;
13600             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
13601             out_ext->pNext = NULL;
13602             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
13603             out_header->pNext = (void *)out_ext;
13604             out_header = (void *)out_ext;
13605             break;
13606         }
13607         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
13608         {
13609             VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13610             const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *)in_header;
13611             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
13612             out_ext->pNext = NULL;
13613             out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
13614             out_header->pNext = (void *)out_ext;
13615             out_header = (void *)out_ext;
13616             break;
13617         }
13618         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
13619         {
13620             VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13621             const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *)in_header;
13622             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
13623             out_ext->pNext = NULL;
13624             out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
13625             out_header->pNext = (void *)out_ext;
13626             out_header = (void *)out_ext;
13627             break;
13628         }
13629         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
13630         {
13631             VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13632             const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *)in_header;
13633             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
13634             out_ext->pNext = NULL;
13635             out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
13636             out_header->pNext = (void *)out_ext;
13637             out_header = (void *)out_ext;
13638             break;
13639         }
13640         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
13641         {
13642             VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13643             const VkPhysicalDeviceShaderObjectFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT32 *)in_header;
13644             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
13645             out_ext->pNext = NULL;
13646             out_ext->shaderObject = in_ext->shaderObject;
13647             out_header->pNext = (void *)out_ext;
13648             out_header = (void *)out_ext;
13649             break;
13650         }
13651         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
13652         {
13653             VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13654             const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *)in_header;
13655             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
13656             out_ext->pNext = NULL;
13657             out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess;
13658             out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess;
13659             out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess;
13660             out_header->pNext = (void *)out_ext;
13661             out_header = (void *)out_ext;
13662             break;
13663         }
13664         default:
13665             FIXME("Unhandled sType %u.\n", in_header->sType);
13666             break;
13667         }
13668     }
13669 }
13670
13671 static inline void convert_VkEventCreateInfo_win32_to_host(const VkEventCreateInfo32 *in, VkEventCreateInfo *out)
13672 {
13673     if (!in) return;
13674
13675     out->sType = in->sType;
13676     out->pNext = NULL;
13677     out->flags = in->flags;
13678     if (in->pNext)
13679         FIXME("Unexpected pNext\n");
13680 }
13681
13682 static inline void convert_VkFenceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkFenceCreateInfo32 *in, VkFenceCreateInfo *out)
13683 {
13684     const VkBaseInStructure32 *in_header;
13685     VkBaseOutStructure *out_header = (void *)out;
13686
13687     if (!in) return;
13688
13689     out->sType = in->sType;
13690     out->pNext = NULL;
13691     out->flags = in->flags;
13692
13693     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
13694     {
13695         switch (in_header->sType)
13696         {
13697         case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
13698         {
13699             VkExportFenceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13700             const VkExportFenceCreateInfo32 *in_ext = (const VkExportFenceCreateInfo32 *)in_header;
13701             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO;
13702             out_ext->pNext = NULL;
13703             out_ext->handleTypes = in_ext->handleTypes;
13704             out_header->pNext = (void *)out_ext;
13705             out_header = (void *)out_ext;
13706             break;
13707         }
13708         default:
13709             FIXME("Unhandled sType %u.\n", in_header->sType);
13710             break;
13711         }
13712     }
13713 }
13714
13715 static inline void convert_VkFramebufferAttachmentImageInfo_win32_to_host(const VkFramebufferAttachmentImageInfo32 *in, VkFramebufferAttachmentImageInfo *out)
13716 {
13717     if (!in) return;
13718
13719     out->sType = in->sType;
13720     out->pNext = NULL;
13721     out->flags = in->flags;
13722     out->usage = in->usage;
13723     out->width = in->width;
13724     out->height = in->height;
13725     out->layerCount = in->layerCount;
13726     out->viewFormatCount = in->viewFormatCount;
13727     out->pViewFormats = (const VkFormat *)UlongToPtr(in->pViewFormats);
13728     if (in->pNext)
13729         FIXME("Unexpected pNext\n");
13730 }
13731
13732 static inline const VkFramebufferAttachmentImageInfo *convert_VkFramebufferAttachmentImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkFramebufferAttachmentImageInfo32 *in, uint32_t count)
13733 {
13734     VkFramebufferAttachmentImageInfo *out;
13735     unsigned int i;
13736
13737     if (!in || !count) return NULL;
13738
13739     out = conversion_context_alloc(ctx, count * sizeof(*out));
13740     for (i = 0; i < count; i++)
13741     {
13742         convert_VkFramebufferAttachmentImageInfo_win32_to_host(&in[i], &out[i]);
13743     }
13744
13745     return out;
13746 }
13747
13748 static inline void convert_VkFramebufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkFramebufferCreateInfo32 *in, VkFramebufferCreateInfo *out)
13749 {
13750     const VkBaseInStructure32 *in_header;
13751     VkBaseOutStructure *out_header = (void *)out;
13752
13753     if (!in) return;
13754
13755     out->sType = in->sType;
13756     out->pNext = NULL;
13757     out->flags = in->flags;
13758     out->renderPass = in->renderPass;
13759     out->attachmentCount = in->attachmentCount;
13760     out->pAttachments = (const VkImageView *)UlongToPtr(in->pAttachments);
13761     out->width = in->width;
13762     out->height = in->height;
13763     out->layers = in->layers;
13764
13765     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
13766     {
13767         switch (in_header->sType)
13768         {
13769         case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
13770         {
13771             VkFramebufferAttachmentsCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13772             const VkFramebufferAttachmentsCreateInfo32 *in_ext = (const VkFramebufferAttachmentsCreateInfo32 *)in_header;
13773             out_ext->sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO;
13774             out_ext->pNext = NULL;
13775             out_ext->attachmentImageInfoCount = in_ext->attachmentImageInfoCount;
13776             out_ext->pAttachmentImageInfos = convert_VkFramebufferAttachmentImageInfo_array_win32_to_host(ctx, (const VkFramebufferAttachmentImageInfo32 *)UlongToPtr(in_ext->pAttachmentImageInfos), in_ext->attachmentImageInfoCount);
13777             out_header->pNext = (void *)out_ext;
13778             out_header = (void *)out_ext;
13779             break;
13780         }
13781         default:
13782             FIXME("Unhandled sType %u.\n", in_header->sType);
13783             break;
13784         }
13785     }
13786 }
13787
13788 #ifdef _WIN64
13789 static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, uint32_t count)
13790 {
13791     VkPipelineShaderStageCreateInfo *out;
13792     unsigned int i;
13793
13794     if (!in || !count) return NULL;
13795
13796     out = conversion_context_alloc(ctx, count * sizeof(*out));
13797     for (i = 0; i < count; i++)
13798     {
13799         convert_VkPipelineShaderStageCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
13800     }
13801
13802     return out;
13803 }
13804 #endif /* _WIN64 */
13805
13806 static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, uint32_t count)
13807 {
13808     VkPipelineShaderStageCreateInfo *out;
13809     unsigned int i;
13810
13811     if (!in || !count) return NULL;
13812
13813     out = conversion_context_alloc(ctx, count * sizeof(*out));
13814     for (i = 0; i < count; i++)
13815     {
13816         convert_VkPipelineShaderStageCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
13817     }
13818
13819     return out;
13820 }
13821
13822 static inline void convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineVertexInputStateCreateInfo32 *in, VkPipelineVertexInputStateCreateInfo *out)
13823 {
13824     const VkBaseInStructure32 *in_header;
13825     VkBaseOutStructure *out_header = (void *)out;
13826
13827     if (!in) return;
13828
13829     out->sType = in->sType;
13830     out->pNext = NULL;
13831     out->flags = in->flags;
13832     out->vertexBindingDescriptionCount = in->vertexBindingDescriptionCount;
13833     out->pVertexBindingDescriptions = (const VkVertexInputBindingDescription *)UlongToPtr(in->pVertexBindingDescriptions);
13834     out->vertexAttributeDescriptionCount = in->vertexAttributeDescriptionCount;
13835     out->pVertexAttributeDescriptions = (const VkVertexInputAttributeDescription *)UlongToPtr(in->pVertexAttributeDescriptions);
13836
13837     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
13838     {
13839         switch (in_header->sType)
13840         {
13841         case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
13842         {
13843             VkPipelineVertexInputDivisorStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13844             const VkPipelineVertexInputDivisorStateCreateInfoEXT32 *in_ext = (const VkPipelineVertexInputDivisorStateCreateInfoEXT32 *)in_header;
13845             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT;
13846             out_ext->pNext = NULL;
13847             out_ext->vertexBindingDivisorCount = in_ext->vertexBindingDivisorCount;
13848             out_ext->pVertexBindingDivisors = (const VkVertexInputBindingDivisorDescriptionEXT *)UlongToPtr(in_ext->pVertexBindingDivisors);
13849             out_header->pNext = (void *)out_ext;
13850             out_header = (void *)out_ext;
13851             break;
13852         }
13853         default:
13854             FIXME("Unhandled sType %u.\n", in_header->sType);
13855             break;
13856         }
13857     }
13858 }
13859
13860 static inline const VkPipelineVertexInputStateCreateInfo *convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineVertexInputStateCreateInfo32 *in, uint32_t count)
13861 {
13862     VkPipelineVertexInputStateCreateInfo *out;
13863     unsigned int i;
13864
13865     if (!in || !count) return NULL;
13866
13867     out = conversion_context_alloc(ctx, count * sizeof(*out));
13868     for (i = 0; i < count; i++)
13869     {
13870         convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
13871     }
13872
13873     return out;
13874 }
13875
13876 static inline void convert_VkPipelineTessellationStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineTessellationStateCreateInfo32 *in, VkPipelineTessellationStateCreateInfo *out)
13877 {
13878     const VkBaseInStructure32 *in_header;
13879     VkBaseOutStructure *out_header = (void *)out;
13880
13881     if (!in) return;
13882
13883     out->sType = in->sType;
13884     out->pNext = NULL;
13885     out->flags = in->flags;
13886     out->patchControlPoints = in->patchControlPoints;
13887
13888     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
13889     {
13890         switch (in_header->sType)
13891         {
13892         case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
13893         {
13894             VkPipelineTessellationDomainOriginStateCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13895             const VkPipelineTessellationDomainOriginStateCreateInfo32 *in_ext = (const VkPipelineTessellationDomainOriginStateCreateInfo32 *)in_header;
13896             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO;
13897             out_ext->pNext = NULL;
13898             out_ext->domainOrigin = in_ext->domainOrigin;
13899             out_header->pNext = (void *)out_ext;
13900             out_header = (void *)out_ext;
13901             break;
13902         }
13903         default:
13904             FIXME("Unhandled sType %u.\n", in_header->sType);
13905             break;
13906         }
13907     }
13908 }
13909
13910 static inline const VkPipelineTessellationStateCreateInfo *convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineTessellationStateCreateInfo32 *in, uint32_t count)
13911 {
13912     VkPipelineTessellationStateCreateInfo *out;
13913     unsigned int i;
13914
13915     if (!in || !count) return NULL;
13916
13917     out = conversion_context_alloc(ctx, count * sizeof(*out));
13918     for (i = 0; i < count; i++)
13919     {
13920         convert_VkPipelineTessellationStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
13921     }
13922
13923     return out;
13924 }
13925
13926 #ifdef _WIN64
13927 static inline void convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, VkGraphicsShaderGroupCreateInfoNV *out)
13928 {
13929     if (!in) return;
13930
13931     out->sType = in->sType;
13932     out->pNext = in->pNext;
13933     out->stageCount = in->stageCount;
13934     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
13935     out->pVertexInputState = in->pVertexInputState;
13936     out->pTessellationState = in->pTessellationState;
13937 }
13938 #endif /* _WIN64 */
13939
13940 static inline void convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, VkGraphicsShaderGroupCreateInfoNV *out)
13941 {
13942     if (!in) return;
13943
13944     out->sType = in->sType;
13945     out->pNext = NULL;
13946     out->stageCount = in->stageCount;
13947     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
13948     out->pVertexInputState = convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineVertexInputStateCreateInfo32 *)UlongToPtr(in->pVertexInputState), 1);
13949     out->pTessellationState = convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineTessellationStateCreateInfo32 *)UlongToPtr(in->pTessellationState), 1);
13950     if (in->pNext)
13951         FIXME("Unexpected pNext\n");
13952 }
13953
13954 #ifdef _WIN64
13955 static inline const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, uint32_t count)
13956 {
13957     VkGraphicsShaderGroupCreateInfoNV *out;
13958     unsigned int i;
13959
13960     if (!in || !count) return NULL;
13961
13962     out = conversion_context_alloc(ctx, count * sizeof(*out));
13963     for (i = 0; i < count; i++)
13964     {
13965         convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]);
13966     }
13967
13968     return out;
13969 }
13970 #endif /* _WIN64 */
13971
13972 static inline const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, uint32_t count)
13973 {
13974     VkGraphicsShaderGroupCreateInfoNV *out;
13975     unsigned int i;
13976
13977     if (!in || !count) return NULL;
13978
13979     out = conversion_context_alloc(ctx, count * sizeof(*out));
13980     for (i = 0; i < count; i++)
13981     {
13982         convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]);
13983     }
13984
13985     return out;
13986 }
13987
13988 static inline void convert_VkPipelineInputAssemblyStateCreateInfo_win32_to_host(const VkPipelineInputAssemblyStateCreateInfo32 *in, VkPipelineInputAssemblyStateCreateInfo *out)
13989 {
13990     if (!in) return;
13991
13992     out->sType = in->sType;
13993     out->pNext = NULL;
13994     out->flags = in->flags;
13995     out->topology = in->topology;
13996     out->primitiveRestartEnable = in->primitiveRestartEnable;
13997     if (in->pNext)
13998         FIXME("Unexpected pNext\n");
13999 }
14000
14001 static inline const VkPipelineInputAssemblyStateCreateInfo *convert_VkPipelineInputAssemblyStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineInputAssemblyStateCreateInfo32 *in, uint32_t count)
14002 {
14003     VkPipelineInputAssemblyStateCreateInfo *out;
14004     unsigned int i;
14005
14006     if (!in || !count) return NULL;
14007
14008     out = conversion_context_alloc(ctx, count * sizeof(*out));
14009     for (i = 0; i < count; i++)
14010     {
14011         convert_VkPipelineInputAssemblyStateCreateInfo_win32_to_host(&in[i], &out[i]);
14012     }
14013
14014     return out;
14015 }
14016
14017 static inline void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineViewportStateCreateInfo32 *in, VkPipelineViewportStateCreateInfo *out)
14018 {
14019     const VkBaseInStructure32 *in_header;
14020     VkBaseOutStructure *out_header = (void *)out;
14021
14022     if (!in) return;
14023
14024     out->sType = in->sType;
14025     out->pNext = NULL;
14026     out->flags = in->flags;
14027     out->viewportCount = in->viewportCount;
14028     out->pViewports = (const VkViewport *)UlongToPtr(in->pViewports);
14029     out->scissorCount = in->scissorCount;
14030     out->pScissors = (const VkRect2D *)UlongToPtr(in->pScissors);
14031
14032     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14033     {
14034         switch (in_header->sType)
14035         {
14036         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
14037         {
14038             VkPipelineViewportWScalingStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14039             const VkPipelineViewportWScalingStateCreateInfoNV32 *in_ext = (const VkPipelineViewportWScalingStateCreateInfoNV32 *)in_header;
14040             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV;
14041             out_ext->pNext = NULL;
14042             out_ext->viewportWScalingEnable = in_ext->viewportWScalingEnable;
14043             out_ext->viewportCount = in_ext->viewportCount;
14044             out_ext->pViewportWScalings = (const VkViewportWScalingNV *)UlongToPtr(in_ext->pViewportWScalings);
14045             out_header->pNext = (void *)out_ext;
14046             out_header = (void *)out_ext;
14047             break;
14048         }
14049         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
14050         {
14051             VkPipelineViewportSwizzleStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14052             const VkPipelineViewportSwizzleStateCreateInfoNV32 *in_ext = (const VkPipelineViewportSwizzleStateCreateInfoNV32 *)in_header;
14053             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV;
14054             out_ext->pNext = NULL;
14055             out_ext->flags = in_ext->flags;
14056             out_ext->viewportCount = in_ext->viewportCount;
14057             out_ext->pViewportSwizzles = (const VkViewportSwizzleNV *)UlongToPtr(in_ext->pViewportSwizzles);
14058             out_header->pNext = (void *)out_ext;
14059             out_header = (void *)out_ext;
14060             break;
14061         }
14062         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
14063         {
14064             VkPipelineViewportExclusiveScissorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14065             const VkPipelineViewportExclusiveScissorStateCreateInfoNV32 *in_ext = (const VkPipelineViewportExclusiveScissorStateCreateInfoNV32 *)in_header;
14066             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV;
14067             out_ext->pNext = NULL;
14068             out_ext->exclusiveScissorCount = in_ext->exclusiveScissorCount;
14069             out_ext->pExclusiveScissors = (const VkRect2D *)UlongToPtr(in_ext->pExclusiveScissors);
14070             out_header->pNext = (void *)out_ext;
14071             out_header = (void *)out_ext;
14072             break;
14073         }
14074         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
14075         {
14076             VkPipelineViewportShadingRateImageStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14077             const VkPipelineViewportShadingRateImageStateCreateInfoNV32 *in_ext = (const VkPipelineViewportShadingRateImageStateCreateInfoNV32 *)in_header;
14078             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV;
14079             out_ext->pNext = NULL;
14080             out_ext->shadingRateImageEnable = in_ext->shadingRateImageEnable;
14081             out_ext->viewportCount = in_ext->viewportCount;
14082             out_ext->pShadingRatePalettes = convert_VkShadingRatePaletteNV_array_win32_to_host(ctx, (const VkShadingRatePaletteNV32 *)UlongToPtr(in_ext->pShadingRatePalettes), in_ext->viewportCount);
14083             out_header->pNext = (void *)out_ext;
14084             out_header = (void *)out_ext;
14085             break;
14086         }
14087         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
14088         {
14089             VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14090             const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *in_ext = (const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *)in_header;
14091             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV;
14092             out_ext->pNext = NULL;
14093             out_ext->sampleOrderType = in_ext->sampleOrderType;
14094             out_ext->customSampleOrderCount = in_ext->customSampleOrderCount;
14095             out_ext->pCustomSampleOrders = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(in_ext->pCustomSampleOrders), in_ext->customSampleOrderCount);
14096             out_header->pNext = (void *)out_ext;
14097             out_header = (void *)out_ext;
14098             break;
14099         }
14100         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
14101         {
14102             VkPipelineViewportDepthClipControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14103             const VkPipelineViewportDepthClipControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClipControlCreateInfoEXT32 *)in_header;
14104             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT;
14105             out_ext->pNext = NULL;
14106             out_ext->negativeOneToOne = in_ext->negativeOneToOne;
14107             out_header->pNext = (void *)out_ext;
14108             out_header = (void *)out_ext;
14109             break;
14110         }
14111         default:
14112             FIXME("Unhandled sType %u.\n", in_header->sType);
14113             break;
14114         }
14115     }
14116 }
14117
14118 static inline const VkPipelineViewportStateCreateInfo *convert_VkPipelineViewportStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineViewportStateCreateInfo32 *in, uint32_t count)
14119 {
14120     VkPipelineViewportStateCreateInfo *out;
14121     unsigned int i;
14122
14123     if (!in || !count) return NULL;
14124
14125     out = conversion_context_alloc(ctx, count * sizeof(*out));
14126     for (i = 0; i < count; i++)
14127     {
14128         convert_VkPipelineViewportStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
14129     }
14130
14131     return out;
14132 }
14133
14134 static inline void convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineRasterizationStateCreateInfo32 *in, VkPipelineRasterizationStateCreateInfo *out)
14135 {
14136     const VkBaseInStructure32 *in_header;
14137     VkBaseOutStructure *out_header = (void *)out;
14138
14139     if (!in) return;
14140
14141     out->sType = in->sType;
14142     out->pNext = NULL;
14143     out->flags = in->flags;
14144     out->depthClampEnable = in->depthClampEnable;
14145     out->rasterizerDiscardEnable = in->rasterizerDiscardEnable;
14146     out->polygonMode = in->polygonMode;
14147     out->cullMode = in->cullMode;
14148     out->frontFace = in->frontFace;
14149     out->depthBiasEnable = in->depthBiasEnable;
14150     out->depthBiasConstantFactor = in->depthBiasConstantFactor;
14151     out->depthBiasClamp = in->depthBiasClamp;
14152     out->depthBiasSlopeFactor = in->depthBiasSlopeFactor;
14153     out->lineWidth = in->lineWidth;
14154
14155     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14156     {
14157         switch (in_header->sType)
14158         {
14159         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
14160         {
14161             VkPipelineRasterizationStateRasterizationOrderAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14162             const VkPipelineRasterizationStateRasterizationOrderAMD32 *in_ext = (const VkPipelineRasterizationStateRasterizationOrderAMD32 *)in_header;
14163             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD;
14164             out_ext->pNext = NULL;
14165             out_ext->rasterizationOrder = in_ext->rasterizationOrder;
14166             out_header->pNext = (void *)out_ext;
14167             out_header = (void *)out_ext;
14168             break;
14169         }
14170         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
14171         {
14172             VkPipelineRasterizationConservativeStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14173             const VkPipelineRasterizationConservativeStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationConservativeStateCreateInfoEXT32 *)in_header;
14174             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT;
14175             out_ext->pNext = NULL;
14176             out_ext->flags = in_ext->flags;
14177             out_ext->conservativeRasterizationMode = in_ext->conservativeRasterizationMode;
14178             out_ext->extraPrimitiveOverestimationSize = in_ext->extraPrimitiveOverestimationSize;
14179             out_header->pNext = (void *)out_ext;
14180             out_header = (void *)out_ext;
14181             break;
14182         }
14183         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
14184         {
14185             VkPipelineRasterizationStateStreamCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14186             const VkPipelineRasterizationStateStreamCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationStateStreamCreateInfoEXT32 *)in_header;
14187             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT;
14188             out_ext->pNext = NULL;
14189             out_ext->flags = in_ext->flags;
14190             out_ext->rasterizationStream = in_ext->rasterizationStream;
14191             out_header->pNext = (void *)out_ext;
14192             out_header = (void *)out_ext;
14193             break;
14194         }
14195         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
14196         {
14197             VkPipelineRasterizationDepthClipStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14198             const VkPipelineRasterizationDepthClipStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationDepthClipStateCreateInfoEXT32 *)in_header;
14199             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT;
14200             out_ext->pNext = NULL;
14201             out_ext->flags = in_ext->flags;
14202             out_ext->depthClipEnable = in_ext->depthClipEnable;
14203             out_header->pNext = (void *)out_ext;
14204             out_header = (void *)out_ext;
14205             break;
14206         }
14207         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
14208         {
14209             VkPipelineRasterizationLineStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14210             const VkPipelineRasterizationLineStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationLineStateCreateInfoEXT32 *)in_header;
14211             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT;
14212             out_ext->pNext = NULL;
14213             out_ext->lineRasterizationMode = in_ext->lineRasterizationMode;
14214             out_ext->stippledLineEnable = in_ext->stippledLineEnable;
14215             out_ext->lineStippleFactor = in_ext->lineStippleFactor;
14216             out_ext->lineStipplePattern = in_ext->lineStipplePattern;
14217             out_header->pNext = (void *)out_ext;
14218             out_header = (void *)out_ext;
14219             break;
14220         }
14221         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
14222         {
14223             VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14224             const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 *)in_header;
14225             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT;
14226             out_ext->pNext = NULL;
14227             out_ext->provokingVertexMode = in_ext->provokingVertexMode;
14228             out_header->pNext = (void *)out_ext;
14229             out_header = (void *)out_ext;
14230             break;
14231         }
14232         default:
14233             FIXME("Unhandled sType %u.\n", in_header->sType);
14234             break;
14235         }
14236     }
14237 }
14238
14239 static inline const VkPipelineRasterizationStateCreateInfo *convert_VkPipelineRasterizationStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineRasterizationStateCreateInfo32 *in, uint32_t count)
14240 {
14241     VkPipelineRasterizationStateCreateInfo *out;
14242     unsigned int i;
14243
14244     if (!in || !count) return NULL;
14245
14246     out = conversion_context_alloc(ctx, count * sizeof(*out));
14247     for (i = 0; i < count; i++)
14248     {
14249         convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
14250     }
14251
14252     return out;
14253 }
14254
14255 static inline void convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineMultisampleStateCreateInfo32 *in, VkPipelineMultisampleStateCreateInfo *out)
14256 {
14257     const VkBaseInStructure32 *in_header;
14258     VkBaseOutStructure *out_header = (void *)out;
14259
14260     if (!in) return;
14261
14262     out->sType = in->sType;
14263     out->pNext = NULL;
14264     out->flags = in->flags;
14265     out->rasterizationSamples = in->rasterizationSamples;
14266     out->sampleShadingEnable = in->sampleShadingEnable;
14267     out->minSampleShading = in->minSampleShading;
14268     out->pSampleMask = (const VkSampleMask *)UlongToPtr(in->pSampleMask);
14269     out->alphaToCoverageEnable = in->alphaToCoverageEnable;
14270     out->alphaToOneEnable = in->alphaToOneEnable;
14271
14272     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14273     {
14274         switch (in_header->sType)
14275         {
14276         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
14277         {
14278             VkPipelineCoverageToColorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14279             const VkPipelineCoverageToColorStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageToColorStateCreateInfoNV32 *)in_header;
14280             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV;
14281             out_ext->pNext = NULL;
14282             out_ext->flags = in_ext->flags;
14283             out_ext->coverageToColorEnable = in_ext->coverageToColorEnable;
14284             out_ext->coverageToColorLocation = in_ext->coverageToColorLocation;
14285             out_header->pNext = (void *)out_ext;
14286             out_header = (void *)out_ext;
14287             break;
14288         }
14289         case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
14290         {
14291             VkPipelineSampleLocationsStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14292             const VkPipelineSampleLocationsStateCreateInfoEXT32 *in_ext = (const VkPipelineSampleLocationsStateCreateInfoEXT32 *)in_header;
14293             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT;
14294             out_ext->pNext = NULL;
14295             out_ext->sampleLocationsEnable = in_ext->sampleLocationsEnable;
14296             convert_VkSampleLocationsInfoEXT_win32_to_host(&in_ext->sampleLocationsInfo, &out_ext->sampleLocationsInfo);
14297             out_header->pNext = (void *)out_ext;
14298             out_header = (void *)out_ext;
14299             break;
14300         }
14301         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
14302         {
14303             VkPipelineCoverageModulationStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14304             const VkPipelineCoverageModulationStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageModulationStateCreateInfoNV32 *)in_header;
14305             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV;
14306             out_ext->pNext = NULL;
14307             out_ext->flags = in_ext->flags;
14308             out_ext->coverageModulationMode = in_ext->coverageModulationMode;
14309             out_ext->coverageModulationTableEnable = in_ext->coverageModulationTableEnable;
14310             out_ext->coverageModulationTableCount = in_ext->coverageModulationTableCount;
14311             out_ext->pCoverageModulationTable = (const float *)UlongToPtr(in_ext->pCoverageModulationTable);
14312             out_header->pNext = (void *)out_ext;
14313             out_header = (void *)out_ext;
14314             break;
14315         }
14316         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
14317         {
14318             VkPipelineCoverageReductionStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14319             const VkPipelineCoverageReductionStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageReductionStateCreateInfoNV32 *)in_header;
14320             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV;
14321             out_ext->pNext = NULL;
14322             out_ext->flags = in_ext->flags;
14323             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
14324             out_header->pNext = (void *)out_ext;
14325             out_header = (void *)out_ext;
14326             break;
14327         }
14328         default:
14329             FIXME("Unhandled sType %u.\n", in_header->sType);
14330             break;
14331         }
14332     }
14333 }
14334
14335 static inline const VkPipelineMultisampleStateCreateInfo *convert_VkPipelineMultisampleStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineMultisampleStateCreateInfo32 *in, uint32_t count)
14336 {
14337     VkPipelineMultisampleStateCreateInfo *out;
14338     unsigned int i;
14339
14340     if (!in || !count) return NULL;
14341
14342     out = conversion_context_alloc(ctx, count * sizeof(*out));
14343     for (i = 0; i < count; i++)
14344     {
14345         convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
14346     }
14347
14348     return out;
14349 }
14350
14351 static inline void convert_VkPipelineDepthStencilStateCreateInfo_win32_to_host(const VkPipelineDepthStencilStateCreateInfo32 *in, VkPipelineDepthStencilStateCreateInfo *out)
14352 {
14353     if (!in) return;
14354
14355     out->sType = in->sType;
14356     out->pNext = NULL;
14357     out->flags = in->flags;
14358     out->depthTestEnable = in->depthTestEnable;
14359     out->depthWriteEnable = in->depthWriteEnable;
14360     out->depthCompareOp = in->depthCompareOp;
14361     out->depthBoundsTestEnable = in->depthBoundsTestEnable;
14362     out->stencilTestEnable = in->stencilTestEnable;
14363     out->front = in->front;
14364     out->back = in->back;
14365     out->minDepthBounds = in->minDepthBounds;
14366     out->maxDepthBounds = in->maxDepthBounds;
14367     if (in->pNext)
14368         FIXME("Unexpected pNext\n");
14369 }
14370
14371 static inline const VkPipelineDepthStencilStateCreateInfo *convert_VkPipelineDepthStencilStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineDepthStencilStateCreateInfo32 *in, uint32_t count)
14372 {
14373     VkPipelineDepthStencilStateCreateInfo *out;
14374     unsigned int i;
14375
14376     if (!in || !count) return NULL;
14377
14378     out = conversion_context_alloc(ctx, count * sizeof(*out));
14379     for (i = 0; i < count; i++)
14380     {
14381         convert_VkPipelineDepthStencilStateCreateInfo_win32_to_host(&in[i], &out[i]);
14382     }
14383
14384     return out;
14385 }
14386
14387 static inline void convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineColorBlendStateCreateInfo32 *in, VkPipelineColorBlendStateCreateInfo *out)
14388 {
14389     const VkBaseInStructure32 *in_header;
14390     VkBaseOutStructure *out_header = (void *)out;
14391
14392     if (!in) return;
14393
14394     out->sType = in->sType;
14395     out->pNext = NULL;
14396     out->flags = in->flags;
14397     out->logicOpEnable = in->logicOpEnable;
14398     out->logicOp = in->logicOp;
14399     out->attachmentCount = in->attachmentCount;
14400     out->pAttachments = (const VkPipelineColorBlendAttachmentState *)UlongToPtr(in->pAttachments);
14401     memcpy(out->blendConstants, in->blendConstants, 4 * sizeof(float));
14402
14403     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14404     {
14405         switch (in_header->sType)
14406         {
14407         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
14408         {
14409             VkPipelineColorBlendAdvancedStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14410             const VkPipelineColorBlendAdvancedStateCreateInfoEXT32 *in_ext = (const VkPipelineColorBlendAdvancedStateCreateInfoEXT32 *)in_header;
14411             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT;
14412             out_ext->pNext = NULL;
14413             out_ext->srcPremultiplied = in_ext->srcPremultiplied;
14414             out_ext->dstPremultiplied = in_ext->dstPremultiplied;
14415             out_ext->blendOverlap = in_ext->blendOverlap;
14416             out_header->pNext = (void *)out_ext;
14417             out_header = (void *)out_ext;
14418             break;
14419         }
14420         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
14421         {
14422             VkPipelineColorWriteCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14423             const VkPipelineColorWriteCreateInfoEXT32 *in_ext = (const VkPipelineColorWriteCreateInfoEXT32 *)in_header;
14424             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT;
14425             out_ext->pNext = NULL;
14426             out_ext->attachmentCount = in_ext->attachmentCount;
14427             out_ext->pColorWriteEnables = (const VkBool32 *)UlongToPtr(in_ext->pColorWriteEnables);
14428             out_header->pNext = (void *)out_ext;
14429             out_header = (void *)out_ext;
14430             break;
14431         }
14432         default:
14433             FIXME("Unhandled sType %u.\n", in_header->sType);
14434             break;
14435         }
14436     }
14437 }
14438
14439 static inline const VkPipelineColorBlendStateCreateInfo *convert_VkPipelineColorBlendStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineColorBlendStateCreateInfo32 *in, uint32_t count)
14440 {
14441     VkPipelineColorBlendStateCreateInfo *out;
14442     unsigned int i;
14443
14444     if (!in || !count) return NULL;
14445
14446     out = conversion_context_alloc(ctx, count * sizeof(*out));
14447     for (i = 0; i < count; i++)
14448     {
14449         convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
14450     }
14451
14452     return out;
14453 }
14454
14455 static inline void convert_VkPipelineDynamicStateCreateInfo_win32_to_host(const VkPipelineDynamicStateCreateInfo32 *in, VkPipelineDynamicStateCreateInfo *out)
14456 {
14457     if (!in) return;
14458
14459     out->sType = in->sType;
14460     out->pNext = NULL;
14461     out->flags = in->flags;
14462     out->dynamicStateCount = in->dynamicStateCount;
14463     out->pDynamicStates = (const VkDynamicState *)UlongToPtr(in->pDynamicStates);
14464     if (in->pNext)
14465         FIXME("Unexpected pNext\n");
14466 }
14467
14468 static inline const VkPipelineDynamicStateCreateInfo *convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineDynamicStateCreateInfo32 *in, uint32_t count)
14469 {
14470     VkPipelineDynamicStateCreateInfo *out;
14471     unsigned int i;
14472
14473     if (!in || !count) return NULL;
14474
14475     out = conversion_context_alloc(ctx, count * sizeof(*out));
14476     for (i = 0; i < count; i++)
14477     {
14478         convert_VkPipelineDynamicStateCreateInfo_win32_to_host(&in[i], &out[i]);
14479     }
14480
14481     return out;
14482 }
14483
14484 #ifdef _WIN64
14485 static inline void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, VkGraphicsPipelineCreateInfo *out)
14486 {
14487     const VkBaseInStructure *in_header;
14488     VkBaseOutStructure *out_header = (void *)out;
14489
14490     if (!in) return;
14491
14492     out->sType = in->sType;
14493     out->pNext = NULL;
14494     out->flags = in->flags;
14495     out->stageCount = in->stageCount;
14496     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
14497     out->pVertexInputState = in->pVertexInputState;
14498     out->pInputAssemblyState = in->pInputAssemblyState;
14499     out->pTessellationState = in->pTessellationState;
14500     out->pViewportState = in->pViewportState;
14501     out->pRasterizationState = in->pRasterizationState;
14502     out->pMultisampleState = in->pMultisampleState;
14503     out->pDepthStencilState = in->pDepthStencilState;
14504     out->pColorBlendState = in->pColorBlendState;
14505     out->pDynamicState = in->pDynamicState;
14506     out->layout = in->layout;
14507     out->renderPass = in->renderPass;
14508     out->subpass = in->subpass;
14509     out->basePipelineHandle = in->basePipelineHandle;
14510     out->basePipelineIndex = in->basePipelineIndex;
14511
14512     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
14513     {
14514         switch (in_header->sType)
14515         {
14516         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
14517         {
14518             VkGraphicsPipelineShaderGroupsCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14519             const VkGraphicsPipelineShaderGroupsCreateInfoNV *in_ext = (const VkGraphicsPipelineShaderGroupsCreateInfoNV *)in_header;
14520             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV;
14521             out_ext->pNext = NULL;
14522             out_ext->groupCount = in_ext->groupCount;
14523             out_ext->pGroups = convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(ctx, in_ext->pGroups, in_ext->groupCount);
14524             out_ext->pipelineCount = in_ext->pipelineCount;
14525             out_ext->pPipelines = in_ext->pPipelines;
14526             out_header->pNext = (void *)out_ext;
14527             out_header = (void *)out_ext;
14528             break;
14529         }
14530         case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
14531         {
14532             VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14533             const VkPipelineDiscardRectangleStateCreateInfoEXT *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT *)in_header;
14534             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
14535             out_ext->pNext = NULL;
14536             out_ext->flags = in_ext->flags;
14537             out_ext->discardRectangleMode = in_ext->discardRectangleMode;
14538             out_ext->discardRectangleCount = in_ext->discardRectangleCount;
14539             out_ext->pDiscardRectangles = in_ext->pDiscardRectangles;
14540             out_header->pNext = (void *)out_ext;
14541             out_header = (void *)out_ext;
14542             break;
14543         }
14544         case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
14545         {
14546             VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14547             const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *)in_header;
14548             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
14549             out_ext->pNext = NULL;
14550             out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable;
14551             out_header->pNext = (void *)out_ext;
14552             out_header = (void *)out_ext;
14553             break;
14554         }
14555         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
14556         {
14557             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14558             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
14559             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
14560             out_ext->pNext = NULL;
14561             out_ext->pPipelineCreationFeedback = in_ext->pPipelineCreationFeedback;
14562             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
14563             out_ext->pPipelineStageCreationFeedbacks = in_ext->pPipelineStageCreationFeedbacks;
14564             out_header->pNext = (void *)out_ext;
14565             out_header = (void *)out_ext;
14566             break;
14567         }
14568         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
14569         {
14570             VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14571             const VkPipelineCompilerControlCreateInfoAMD *in_ext = (const VkPipelineCompilerControlCreateInfoAMD *)in_header;
14572             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
14573             out_ext->pNext = NULL;
14574             out_ext->compilerControlFlags = in_ext->compilerControlFlags;
14575             out_header->pNext = (void *)out_ext;
14576             out_header = (void *)out_ext;
14577             break;
14578         }
14579         case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
14580         {
14581             VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14582             const VkPipelineLibraryCreateInfoKHR *in_ext = (const VkPipelineLibraryCreateInfoKHR *)in_header;
14583             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
14584             out_ext->pNext = NULL;
14585             out_ext->libraryCount = in_ext->libraryCount;
14586             out_ext->pLibraries = in_ext->pLibraries;
14587             out_header->pNext = (void *)out_ext;
14588             out_header = (void *)out_ext;
14589             break;
14590         }
14591         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
14592         {
14593             VkPipelineFragmentShadingRateStateCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14594             const VkPipelineFragmentShadingRateStateCreateInfoKHR *in_ext = (const VkPipelineFragmentShadingRateStateCreateInfoKHR *)in_header;
14595             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR;
14596             out_ext->pNext = NULL;
14597             out_ext->fragmentSize = in_ext->fragmentSize;
14598             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
14599             out_header->pNext = (void *)out_ext;
14600             out_header = (void *)out_ext;
14601             break;
14602         }
14603         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
14604         {
14605             VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14606             const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *)in_header;
14607             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
14608             out_ext->pNext = NULL;
14609             out_ext->shadingRateType = in_ext->shadingRateType;
14610             out_ext->shadingRate = in_ext->shadingRate;
14611             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
14612             out_header->pNext = (void *)out_ext;
14613             out_header = (void *)out_ext;
14614             break;
14615         }
14616         case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
14617         {
14618             VkPipelineRenderingCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14619             const VkPipelineRenderingCreateInfo *in_ext = (const VkPipelineRenderingCreateInfo *)in_header;
14620             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
14621             out_ext->pNext = NULL;
14622             out_ext->viewMask = in_ext->viewMask;
14623             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
14624             out_ext->pColorAttachmentFormats = in_ext->pColorAttachmentFormats;
14625             out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
14626             out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
14627             out_header->pNext = (void *)out_ext;
14628             out_header = (void *)out_ext;
14629             break;
14630         }
14631         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
14632         {
14633             VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14634             const VkAttachmentSampleCountInfoAMD *in_ext = (const VkAttachmentSampleCountInfoAMD *)in_header;
14635             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
14636             out_ext->pNext = NULL;
14637             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
14638             out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples;
14639             out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
14640             out_header->pNext = (void *)out_ext;
14641             out_header = (void *)out_ext;
14642             break;
14643         }
14644         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
14645         {
14646             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14647             const VkMultiviewPerViewAttributesInfoNVX *in_ext = (const VkMultiviewPerViewAttributesInfoNVX *)in_header;
14648             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
14649             out_ext->pNext = NULL;
14650             out_ext->perViewAttributes = in_ext->perViewAttributes;
14651             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
14652             out_header->pNext = (void *)out_ext;
14653             out_header = (void *)out_ext;
14654             break;
14655         }
14656         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
14657         {
14658             VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14659             const VkGraphicsPipelineLibraryCreateInfoEXT *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT *)in_header;
14660             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
14661             out_ext->pNext = NULL;
14662             out_ext->flags = in_ext->flags;
14663             out_header->pNext = (void *)out_ext;
14664             out_header = (void *)out_ext;
14665             break;
14666         }
14667         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
14668         {
14669             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14670             const VkPipelineRobustnessCreateInfoEXT *in_ext = (const VkPipelineRobustnessCreateInfoEXT *)in_header;
14671             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
14672             out_ext->pNext = NULL;
14673             out_ext->storageBuffers = in_ext->storageBuffers;
14674             out_ext->uniformBuffers = in_ext->uniformBuffers;
14675             out_ext->vertexInputs = in_ext->vertexInputs;
14676             out_ext->images = in_ext->images;
14677             out_header->pNext = (void *)out_ext;
14678             out_header = (void *)out_ext;
14679             break;
14680         }
14681         default:
14682             FIXME("Unhandled sType %u.\n", in_header->sType);
14683             break;
14684         }
14685     }
14686 }
14687 #endif /* _WIN64 */
14688
14689 static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, VkGraphicsPipelineCreateInfo *out)
14690 {
14691     const VkBaseInStructure32 *in_header;
14692     VkBaseOutStructure *out_header = (void *)out;
14693
14694     if (!in) return;
14695
14696     out->sType = in->sType;
14697     out->pNext = NULL;
14698     out->flags = in->flags;
14699     out->stageCount = in->stageCount;
14700     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
14701     out->pVertexInputState = convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineVertexInputStateCreateInfo32 *)UlongToPtr(in->pVertexInputState), 1);
14702     out->pInputAssemblyState = convert_VkPipelineInputAssemblyStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineInputAssemblyStateCreateInfo32 *)UlongToPtr(in->pInputAssemblyState), 1);
14703     out->pTessellationState = convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineTessellationStateCreateInfo32 *)UlongToPtr(in->pTessellationState), 1);
14704     out->pViewportState = convert_VkPipelineViewportStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineViewportStateCreateInfo32 *)UlongToPtr(in->pViewportState), 1);
14705     out->pRasterizationState = convert_VkPipelineRasterizationStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineRasterizationStateCreateInfo32 *)UlongToPtr(in->pRasterizationState), 1);
14706     out->pMultisampleState = convert_VkPipelineMultisampleStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineMultisampleStateCreateInfo32 *)UlongToPtr(in->pMultisampleState), 1);
14707     out->pDepthStencilState = convert_VkPipelineDepthStencilStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineDepthStencilStateCreateInfo32 *)UlongToPtr(in->pDepthStencilState), 1);
14708     out->pColorBlendState = convert_VkPipelineColorBlendStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineColorBlendStateCreateInfo32 *)UlongToPtr(in->pColorBlendState), 1);
14709     out->pDynamicState = convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineDynamicStateCreateInfo32 *)UlongToPtr(in->pDynamicState), 1);
14710     out->layout = in->layout;
14711     out->renderPass = in->renderPass;
14712     out->subpass = in->subpass;
14713     out->basePipelineHandle = in->basePipelineHandle;
14714     out->basePipelineIndex = in->basePipelineIndex;
14715
14716     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14717     {
14718         switch (in_header->sType)
14719         {
14720         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
14721         {
14722             VkGraphicsPipelineShaderGroupsCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14723             const VkGraphicsPipelineShaderGroupsCreateInfoNV32 *in_ext = (const VkGraphicsPipelineShaderGroupsCreateInfoNV32 *)in_header;
14724             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV;
14725             out_ext->pNext = NULL;
14726             out_ext->groupCount = in_ext->groupCount;
14727             out_ext->pGroups = convert_VkGraphicsShaderGroupCreateInfoNV_array_win32_to_host(ctx, (const VkGraphicsShaderGroupCreateInfoNV32 *)UlongToPtr(in_ext->pGroups), in_ext->groupCount);
14728             out_ext->pipelineCount = in_ext->pipelineCount;
14729             out_ext->pPipelines = (const VkPipeline *)UlongToPtr(in_ext->pPipelines);
14730             out_header->pNext = (void *)out_ext;
14731             out_header = (void *)out_ext;
14732             break;
14733         }
14734         case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
14735         {
14736             VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14737             const VkPipelineDiscardRectangleStateCreateInfoEXT32 *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT32 *)in_header;
14738             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
14739             out_ext->pNext = NULL;
14740             out_ext->flags = in_ext->flags;
14741             out_ext->discardRectangleMode = in_ext->discardRectangleMode;
14742             out_ext->discardRectangleCount = in_ext->discardRectangleCount;
14743             out_ext->pDiscardRectangles = (const VkRect2D *)UlongToPtr(in_ext->pDiscardRectangles);
14744             out_header->pNext = (void *)out_ext;
14745             out_header = (void *)out_ext;
14746             break;
14747         }
14748         case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
14749         {
14750             VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14751             const VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 *)in_header;
14752             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
14753             out_ext->pNext = NULL;
14754             out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable;
14755             out_header->pNext = (void *)out_ext;
14756             out_header = (void *)out_ext;
14757             break;
14758         }
14759         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
14760         {
14761             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14762             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
14763             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
14764             out_ext->pNext = NULL;
14765             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
14766             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
14767             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
14768             out_header->pNext = (void *)out_ext;
14769             out_header = (void *)out_ext;
14770             break;
14771         }
14772         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
14773         {
14774             VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14775             const VkPipelineCompilerControlCreateInfoAMD32 *in_ext = (const VkPipelineCompilerControlCreateInfoAMD32 *)in_header;
14776             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
14777             out_ext->pNext = NULL;
14778             out_ext->compilerControlFlags = in_ext->compilerControlFlags;
14779             out_header->pNext = (void *)out_ext;
14780             out_header = (void *)out_ext;
14781             break;
14782         }
14783         case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
14784         {
14785             VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14786             const VkPipelineLibraryCreateInfoKHR32 *in_ext = (const VkPipelineLibraryCreateInfoKHR32 *)in_header;
14787             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
14788             out_ext->pNext = NULL;
14789             out_ext->libraryCount = in_ext->libraryCount;
14790             out_ext->pLibraries = (const VkPipeline *)UlongToPtr(in_ext->pLibraries);
14791             out_header->pNext = (void *)out_ext;
14792             out_header = (void *)out_ext;
14793             break;
14794         }
14795         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
14796         {
14797             VkPipelineFragmentShadingRateStateCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14798             const VkPipelineFragmentShadingRateStateCreateInfoKHR32 *in_ext = (const VkPipelineFragmentShadingRateStateCreateInfoKHR32 *)in_header;
14799             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR;
14800             out_ext->pNext = NULL;
14801             out_ext->fragmentSize = in_ext->fragmentSize;
14802             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
14803             out_header->pNext = (void *)out_ext;
14804             out_header = (void *)out_ext;
14805             break;
14806         }
14807         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
14808         {
14809             VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14810             const VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 *)in_header;
14811             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
14812             out_ext->pNext = NULL;
14813             out_ext->shadingRateType = in_ext->shadingRateType;
14814             out_ext->shadingRate = in_ext->shadingRate;
14815             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
14816             out_header->pNext = (void *)out_ext;
14817             out_header = (void *)out_ext;
14818             break;
14819         }
14820         case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
14821         {
14822             VkPipelineRenderingCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14823             const VkPipelineRenderingCreateInfo32 *in_ext = (const VkPipelineRenderingCreateInfo32 *)in_header;
14824             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
14825             out_ext->pNext = NULL;
14826             out_ext->viewMask = in_ext->viewMask;
14827             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
14828             out_ext->pColorAttachmentFormats = (const VkFormat *)UlongToPtr(in_ext->pColorAttachmentFormats);
14829             out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
14830             out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
14831             out_header->pNext = (void *)out_ext;
14832             out_header = (void *)out_ext;
14833             break;
14834         }
14835         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
14836         {
14837             VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14838             const VkAttachmentSampleCountInfoAMD32 *in_ext = (const VkAttachmentSampleCountInfoAMD32 *)in_header;
14839             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
14840             out_ext->pNext = NULL;
14841             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
14842             out_ext->pColorAttachmentSamples = (const VkSampleCountFlagBits *)UlongToPtr(in_ext->pColorAttachmentSamples);
14843             out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
14844             out_header->pNext = (void *)out_ext;
14845             out_header = (void *)out_ext;
14846             break;
14847         }
14848         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
14849         {
14850             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14851             const VkMultiviewPerViewAttributesInfoNVX32 *in_ext = (const VkMultiviewPerViewAttributesInfoNVX32 *)in_header;
14852             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
14853             out_ext->pNext = NULL;
14854             out_ext->perViewAttributes = in_ext->perViewAttributes;
14855             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
14856             out_header->pNext = (void *)out_ext;
14857             out_header = (void *)out_ext;
14858             break;
14859         }
14860         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
14861         {
14862             VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14863             const VkGraphicsPipelineLibraryCreateInfoEXT32 *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT32 *)in_header;
14864             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
14865             out_ext->pNext = NULL;
14866             out_ext->flags = in_ext->flags;
14867             out_header->pNext = (void *)out_ext;
14868             out_header = (void *)out_ext;
14869             break;
14870         }
14871         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
14872         {
14873             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14874             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
14875             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
14876             out_ext->pNext = NULL;
14877             out_ext->storageBuffers = in_ext->storageBuffers;
14878             out_ext->uniformBuffers = in_ext->uniformBuffers;
14879             out_ext->vertexInputs = in_ext->vertexInputs;
14880             out_ext->images = in_ext->images;
14881             out_header->pNext = (void *)out_ext;
14882             out_header = (void *)out_ext;
14883             break;
14884         }
14885         default:
14886             FIXME("Unhandled sType %u.\n", in_header->sType);
14887             break;
14888         }
14889     }
14890 }
14891
14892 static inline void convert_VkGraphicsPipelineCreateInfo_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out)
14893 {
14894     const VkBaseInStructure *in_header;
14895     VkBaseOutStructure32 *out_header = (void *)out;
14896
14897     if (!in) return;
14898
14899
14900     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
14901     {
14902         switch (in_header->sType)
14903         {
14904         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
14905         {
14906             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
14907             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
14908             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
14909             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
14910             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
14911             out_header = (void *)out_ext;
14912             break;
14913         }
14914         default:
14915             break;
14916         }
14917     }
14918 }
14919
14920 #ifdef _WIN64
14921 static inline const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, uint32_t count)
14922 {
14923     VkGraphicsPipelineCreateInfo *out;
14924     unsigned int i;
14925
14926     if (!in || !count) return NULL;
14927
14928     out = conversion_context_alloc(ctx, count * sizeof(*out));
14929     for (i = 0; i < count; i++)
14930     {
14931         convert_VkGraphicsPipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
14932     }
14933
14934     return out;
14935 }
14936 #endif /* _WIN64 */
14937
14938 static inline const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, uint32_t count)
14939 {
14940     VkGraphicsPipelineCreateInfo *out;
14941     unsigned int i;
14942
14943     if (!in || !count) return NULL;
14944
14945     out = conversion_context_alloc(ctx, count * sizeof(*out));
14946     for (i = 0; i < count; i++)
14947     {
14948         convert_VkGraphicsPipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
14949     }
14950
14951     return out;
14952 }
14953
14954 static inline void convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out, uint32_t count)
14955 {
14956     unsigned int i;
14957
14958     if (!in) return;
14959
14960     for (i = 0; i < count; i++)
14961     {
14962         convert_VkGraphicsPipelineCreateInfo_host_to_win32(&in[i], &out[i]);
14963     }
14964 }
14965
14966 static inline void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo32 *in, VkImageCreateInfo *out)
14967 {
14968     const VkBaseInStructure32 *in_header;
14969     VkBaseOutStructure *out_header = (void *)out;
14970
14971     if (!in) return;
14972
14973     out->sType = in->sType;
14974     out->pNext = NULL;
14975     out->flags = in->flags;
14976     out->imageType = in->imageType;
14977     out->format = in->format;
14978     out->extent = in->extent;
14979     out->mipLevels = in->mipLevels;
14980     out->arrayLayers = in->arrayLayers;
14981     out->samples = in->samples;
14982     out->tiling = in->tiling;
14983     out->usage = in->usage;
14984     out->sharingMode = in->sharingMode;
14985     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
14986     out->pQueueFamilyIndices = (const uint32_t *)UlongToPtr(in->pQueueFamilyIndices);
14987     out->initialLayout = in->initialLayout;
14988
14989     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14990     {
14991         switch (in_header->sType)
14992         {
14993         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
14994         {
14995             VkDedicatedAllocationImageCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14996             const VkDedicatedAllocationImageCreateInfoNV32 *in_ext = (const VkDedicatedAllocationImageCreateInfoNV32 *)in_header;
14997             out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV;
14998             out_ext->pNext = NULL;
14999             out_ext->dedicatedAllocation = in_ext->dedicatedAllocation;
15000             out_header->pNext = (void *)out_ext;
15001             out_header = (void *)out_ext;
15002             break;
15003         }
15004         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
15005         {
15006             VkExternalMemoryImageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15007             const VkExternalMemoryImageCreateInfo32 *in_ext = (const VkExternalMemoryImageCreateInfo32 *)in_header;
15008             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
15009             out_ext->pNext = NULL;
15010             out_ext->handleTypes = in_ext->handleTypes;
15011             out_header->pNext = (void *)out_ext;
15012             out_header = (void *)out_ext;
15013             break;
15014         }
15015         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
15016         {
15017             VkImageSwapchainCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15018             const VkImageSwapchainCreateInfoKHR32 *in_ext = (const VkImageSwapchainCreateInfoKHR32 *)in_header;
15019             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR;
15020             out_ext->pNext = NULL;
15021             out_ext->swapchain = in_ext->swapchain;
15022             out_header->pNext = (void *)out_ext;
15023             out_header = (void *)out_ext;
15024             break;
15025         }
15026         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
15027         {
15028             VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15029             const VkImageFormatListCreateInfo32 *in_ext = (const VkImageFormatListCreateInfo32 *)in_header;
15030             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
15031             out_ext->pNext = NULL;
15032             out_ext->viewFormatCount = in_ext->viewFormatCount;
15033             out_ext->pViewFormats = (const VkFormat *)UlongToPtr(in_ext->pViewFormats);
15034             out_header->pNext = (void *)out_ext;
15035             out_header = (void *)out_ext;
15036             break;
15037         }
15038         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
15039         {
15040             VkImageStencilUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15041             const VkImageStencilUsageCreateInfo32 *in_ext = (const VkImageStencilUsageCreateInfo32 *)in_header;
15042             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO;
15043             out_ext->pNext = NULL;
15044             out_ext->stencilUsage = in_ext->stencilUsage;
15045             out_header->pNext = (void *)out_ext;
15046             out_header = (void *)out_ext;
15047             break;
15048         }
15049         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
15050         {
15051             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15052             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
15053             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
15054             out_ext->pNext = NULL;
15055             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
15056             out_header->pNext = (void *)out_ext;
15057             out_header = (void *)out_ext;
15058             break;
15059         }
15060         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
15061         {
15062             VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15063             const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
15064             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
15065             out_ext->pNext = NULL;
15066             out_ext->flags = in_ext->flags;
15067             out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
15068             out_ext->pFixedRateFlags = (VkImageCompressionFixedRateFlagsEXT *)UlongToPtr(in_ext->pFixedRateFlags);
15069             out_header->pNext = (void *)out_ext;
15070             out_header = (void *)out_ext;
15071             break;
15072         }
15073         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
15074         {
15075             VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15076             const VkOpticalFlowImageFormatInfoNV32 *in_ext = (const VkOpticalFlowImageFormatInfoNV32 *)in_header;
15077             out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV;
15078             out_ext->pNext = NULL;
15079             out_ext->usage = in_ext->usage;
15080             out_header->pNext = (void *)out_ext;
15081             out_header = (void *)out_ext;
15082             break;
15083         }
15084         default:
15085             FIXME("Unhandled sType %u.\n", in_header->sType);
15086             break;
15087         }
15088     }
15089 }
15090
15091 static inline void convert_VkImageViewCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageViewCreateInfo32 *in, VkImageViewCreateInfo *out)
15092 {
15093     const VkBaseInStructure32 *in_header;
15094     VkBaseOutStructure *out_header = (void *)out;
15095
15096     if (!in) return;
15097
15098     out->sType = in->sType;
15099     out->pNext = NULL;
15100     out->flags = in->flags;
15101     out->image = in->image;
15102     out->viewType = in->viewType;
15103     out->format = in->format;
15104     out->components = in->components;
15105     out->subresourceRange = in->subresourceRange;
15106
15107     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15108     {
15109         switch (in_header->sType)
15110         {
15111         case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
15112         {
15113             VkImageViewUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15114             const VkImageViewUsageCreateInfo32 *in_ext = (const VkImageViewUsageCreateInfo32 *)in_header;
15115             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO;
15116             out_ext->pNext = NULL;
15117             out_ext->usage = in_ext->usage;
15118             out_header->pNext = (void *)out_ext;
15119             out_header = (void *)out_ext;
15120             break;
15121         }
15122         case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT:
15123         {
15124             VkImageViewSlicedCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15125             const VkImageViewSlicedCreateInfoEXT32 *in_ext = (const VkImageViewSlicedCreateInfoEXT32 *)in_header;
15126             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT;
15127             out_ext->pNext = NULL;
15128             out_ext->sliceOffset = in_ext->sliceOffset;
15129             out_ext->sliceCount = in_ext->sliceCount;
15130             out_header->pNext = (void *)out_ext;
15131             out_header = (void *)out_ext;
15132             break;
15133         }
15134         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
15135         {
15136             VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15137             const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header;
15138             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
15139             out_ext->pNext = NULL;
15140             out_ext->conversion = in_ext->conversion;
15141             out_header->pNext = (void *)out_ext;
15142             out_header = (void *)out_ext;
15143             break;
15144         }
15145         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
15146         {
15147             VkImageViewASTCDecodeModeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15148             const VkImageViewASTCDecodeModeEXT32 *in_ext = (const VkImageViewASTCDecodeModeEXT32 *)in_header;
15149             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT;
15150             out_ext->pNext = NULL;
15151             out_ext->decodeMode = in_ext->decodeMode;
15152             out_header->pNext = (void *)out_ext;
15153             out_header = (void *)out_ext;
15154             break;
15155         }
15156         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
15157         {
15158             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15159             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
15160             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
15161             out_ext->pNext = NULL;
15162             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
15163             out_header->pNext = (void *)out_ext;
15164             out_header = (void *)out_ext;
15165             break;
15166         }
15167         case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
15168         {
15169             VkImageViewMinLodCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15170             const VkImageViewMinLodCreateInfoEXT32 *in_ext = (const VkImageViewMinLodCreateInfoEXT32 *)in_header;
15171             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT;
15172             out_ext->pNext = NULL;
15173             out_ext->minLod = in_ext->minLod;
15174             out_header->pNext = (void *)out_ext;
15175             out_header = (void *)out_ext;
15176             break;
15177         }
15178         case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM:
15179         {
15180             VkImageViewSampleWeightCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15181             const VkImageViewSampleWeightCreateInfoQCOM32 *in_ext = (const VkImageViewSampleWeightCreateInfoQCOM32 *)in_header;
15182             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM;
15183             out_ext->pNext = NULL;
15184             out_ext->filterCenter = in_ext->filterCenter;
15185             out_ext->filterSize = in_ext->filterSize;
15186             out_ext->numPhases = in_ext->numPhases;
15187             out_header->pNext = (void *)out_ext;
15188             out_header = (void *)out_ext;
15189             break;
15190         }
15191         default:
15192             FIXME("Unhandled sType %u.\n", in_header->sType);
15193             break;
15194         }
15195     }
15196 }
15197
15198 static inline void convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(const VkIndirectCommandsLayoutTokenNV32 *in, VkIndirectCommandsLayoutTokenNV *out)
15199 {
15200     if (!in) return;
15201
15202     out->sType = in->sType;
15203     out->pNext = NULL;
15204     out->tokenType = in->tokenType;
15205     out->stream = in->stream;
15206     out->offset = in->offset;
15207     out->vertexBindingUnit = in->vertexBindingUnit;
15208     out->vertexDynamicStride = in->vertexDynamicStride;
15209     out->pushconstantPipelineLayout = in->pushconstantPipelineLayout;
15210     out->pushconstantShaderStageFlags = in->pushconstantShaderStageFlags;
15211     out->pushconstantOffset = in->pushconstantOffset;
15212     out->pushconstantSize = in->pushconstantSize;
15213     out->indirectStateFlags = in->indirectStateFlags;
15214     out->indexTypeCount = in->indexTypeCount;
15215     out->pIndexTypes = (const VkIndexType *)UlongToPtr(in->pIndexTypes);
15216     out->pIndexTypeValues = (const uint32_t *)UlongToPtr(in->pIndexTypeValues);
15217     if (in->pNext)
15218         FIXME("Unexpected pNext\n");
15219 }
15220
15221 static inline const VkIndirectCommandsLayoutTokenNV *convert_VkIndirectCommandsLayoutTokenNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutTokenNV32 *in, uint32_t count)
15222 {
15223     VkIndirectCommandsLayoutTokenNV *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_VkIndirectCommandsLayoutTokenNV_win32_to_host(&in[i], &out[i]);
15232     }
15233
15234     return out;
15235 }
15236
15237 static inline void convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutCreateInfoNV32 *in, VkIndirectCommandsLayoutCreateInfoNV *out)
15238 {
15239     if (!in) return;
15240
15241     out->sType = in->sType;
15242     out->pNext = NULL;
15243     out->flags = in->flags;
15244     out->pipelineBindPoint = in->pipelineBindPoint;
15245     out->tokenCount = in->tokenCount;
15246     out->pTokens = convert_VkIndirectCommandsLayoutTokenNV_array_win32_to_host(ctx, (const VkIndirectCommandsLayoutTokenNV32 *)UlongToPtr(in->pTokens), in->tokenCount);
15247     out->streamCount = in->streamCount;
15248     out->pStreamStrides = (const uint32_t *)UlongToPtr(in->pStreamStrides);
15249     if (in->pNext)
15250         FIXME("Unexpected pNext\n");
15251 }
15252
15253 static inline void convert_VkApplicationInfo_win32_to_host(const VkApplicationInfo32 *in, VkApplicationInfo *out)
15254 {
15255     if (!in) return;
15256
15257     out->sType = in->sType;
15258     out->pNext = NULL;
15259     out->pApplicationName = (const char *)UlongToPtr(in->pApplicationName);
15260     out->applicationVersion = in->applicationVersion;
15261     out->pEngineName = (const char *)UlongToPtr(in->pEngineName);
15262     out->engineVersion = in->engineVersion;
15263     out->apiVersion = in->apiVersion;
15264     if (in->pNext)
15265         FIXME("Unexpected pNext\n");
15266 }
15267
15268 static inline const VkApplicationInfo *convert_VkApplicationInfo_array_win32_to_host(struct conversion_context *ctx, const VkApplicationInfo32 *in, uint32_t count)
15269 {
15270     VkApplicationInfo *out;
15271     unsigned int i;
15272
15273     if (!in || !count) return NULL;
15274
15275     out = conversion_context_alloc(ctx, count * sizeof(*out));
15276     for (i = 0; i < count; i++)
15277     {
15278         convert_VkApplicationInfo_win32_to_host(&in[i], &out[i]);
15279     }
15280
15281     return out;
15282 }
15283
15284 #ifdef _WIN64
15285 static inline void convert_VkInstanceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo *in, VkInstanceCreateInfo *out)
15286 {
15287     const VkBaseInStructure *in_header;
15288     VkBaseOutStructure *out_header = (void *)out;
15289
15290     if (!in) return;
15291
15292     out->sType = in->sType;
15293     out->pNext = NULL;
15294     out->flags = in->flags;
15295     out->pApplicationInfo = in->pApplicationInfo;
15296     out->enabledLayerCount = in->enabledLayerCount;
15297     out->ppEnabledLayerNames = in->ppEnabledLayerNames;
15298     out->enabledExtensionCount = in->enabledExtensionCount;
15299     out->ppEnabledExtensionNames = in->ppEnabledExtensionNames;
15300
15301     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
15302     {
15303         switch (in_header->sType)
15304         {
15305         case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
15306             break;
15307         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
15308         {
15309             VkDebugReportCallbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15310             const VkDebugReportCallbackCreateInfoEXT *in_ext = (const VkDebugReportCallbackCreateInfoEXT *)in_header;
15311             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
15312             out_ext->pNext = NULL;
15313             out_ext->flags = in_ext->flags;
15314             out_ext->pfnCallback = in_ext->pfnCallback;
15315             out_ext->pUserData = in_ext->pUserData;
15316             out_header->pNext = (void *)out_ext;
15317             out_header = (void *)out_ext;
15318             break;
15319         }
15320         case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
15321         {
15322             VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15323             const VkValidationFlagsEXT *in_ext = (const VkValidationFlagsEXT *)in_header;
15324             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT;
15325             out_ext->pNext = NULL;
15326             out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount;
15327             out_ext->pDisabledValidationChecks = in_ext->pDisabledValidationChecks;
15328             out_header->pNext = (void *)out_ext;
15329             out_header = (void *)out_ext;
15330             break;
15331         }
15332         case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
15333         {
15334             VkValidationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15335             const VkValidationFeaturesEXT *in_ext = (const VkValidationFeaturesEXT *)in_header;
15336             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT;
15337             out_ext->pNext = NULL;
15338             out_ext->enabledValidationFeatureCount = in_ext->enabledValidationFeatureCount;
15339             out_ext->pEnabledValidationFeatures = in_ext->pEnabledValidationFeatures;
15340             out_ext->disabledValidationFeatureCount = in_ext->disabledValidationFeatureCount;
15341             out_ext->pDisabledValidationFeatures = in_ext->pDisabledValidationFeatures;
15342             out_header->pNext = (void *)out_ext;
15343             out_header = (void *)out_ext;
15344             break;
15345         }
15346         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
15347         {
15348             VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15349             const VkDebugUtilsMessengerCreateInfoEXT *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT *)in_header;
15350             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
15351             out_ext->pNext = NULL;
15352             out_ext->flags = in_ext->flags;
15353             out_ext->messageSeverity = in_ext->messageSeverity;
15354             out_ext->messageType = in_ext->messageType;
15355             out_ext->pfnUserCallback = in_ext->pfnUserCallback;
15356             out_ext->pUserData = in_ext->pUserData;
15357             out_header->pNext = (void *)out_ext;
15358             out_header = (void *)out_ext;
15359             break;
15360         }
15361         default:
15362             FIXME("Unhandled sType %u.\n", in_header->sType);
15363             break;
15364         }
15365     }
15366 }
15367 #endif /* _WIN64 */
15368
15369 static inline void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo32 *in, VkInstanceCreateInfo *out)
15370 {
15371     const VkBaseInStructure32 *in_header;
15372     VkBaseOutStructure *out_header = (void *)out;
15373
15374     if (!in) return;
15375
15376     out->sType = in->sType;
15377     out->pNext = NULL;
15378     out->flags = in->flags;
15379     out->pApplicationInfo = convert_VkApplicationInfo_array_win32_to_host(ctx, (const VkApplicationInfo32 *)UlongToPtr(in->pApplicationInfo), 1);
15380     out->enabledLayerCount = in->enabledLayerCount;
15381     out->ppEnabledLayerNames = convert_char_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppEnabledLayerNames), in->enabledLayerCount);
15382     out->enabledExtensionCount = in->enabledExtensionCount;
15383     out->ppEnabledExtensionNames = convert_char_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppEnabledExtensionNames), in->enabledExtensionCount);
15384
15385     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15386     {
15387         switch (in_header->sType)
15388         {
15389         case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
15390             break;
15391         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
15392         {
15393             VkDebugReportCallbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15394             const VkDebugReportCallbackCreateInfoEXT32 *in_ext = (const VkDebugReportCallbackCreateInfoEXT32 *)in_header;
15395             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
15396             out_ext->pNext = NULL;
15397             out_ext->flags = in_ext->flags;
15398             out_ext->pfnCallback = in_ext->pfnCallback;
15399             out_ext->pUserData = (void *)UlongToPtr(in_ext->pUserData);
15400             out_header->pNext = (void *)out_ext;
15401             out_header = (void *)out_ext;
15402             break;
15403         }
15404         case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
15405         {
15406             VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15407             const VkValidationFlagsEXT32 *in_ext = (const VkValidationFlagsEXT32 *)in_header;
15408             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT;
15409             out_ext->pNext = NULL;
15410             out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount;
15411             out_ext->pDisabledValidationChecks = (const VkValidationCheckEXT *)UlongToPtr(in_ext->pDisabledValidationChecks);
15412             out_header->pNext = (void *)out_ext;
15413             out_header = (void *)out_ext;
15414             break;
15415         }
15416         case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
15417         {
15418             VkValidationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15419             const VkValidationFeaturesEXT32 *in_ext = (const VkValidationFeaturesEXT32 *)in_header;
15420             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT;
15421             out_ext->pNext = NULL;
15422             out_ext->enabledValidationFeatureCount = in_ext->enabledValidationFeatureCount;
15423             out_ext->pEnabledValidationFeatures = (const VkValidationFeatureEnableEXT *)UlongToPtr(in_ext->pEnabledValidationFeatures);
15424             out_ext->disabledValidationFeatureCount = in_ext->disabledValidationFeatureCount;
15425             out_ext->pDisabledValidationFeatures = (const VkValidationFeatureDisableEXT *)UlongToPtr(in_ext->pDisabledValidationFeatures);
15426             out_header->pNext = (void *)out_ext;
15427             out_header = (void *)out_ext;
15428             break;
15429         }
15430         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
15431         {
15432             VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15433             const VkDebugUtilsMessengerCreateInfoEXT32 *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT32 *)in_header;
15434             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
15435             out_ext->pNext = NULL;
15436             out_ext->flags = in_ext->flags;
15437             out_ext->messageSeverity = in_ext->messageSeverity;
15438             out_ext->messageType = in_ext->messageType;
15439             out_ext->pfnUserCallback = in_ext->pfnUserCallback;
15440             out_ext->pUserData = (void *)UlongToPtr(in_ext->pUserData);
15441             out_header->pNext = (void *)out_ext;
15442             out_header = (void *)out_ext;
15443             break;
15444         }
15445         default:
15446             FIXME("Unhandled sType %u.\n", in_header->sType);
15447             break;
15448         }
15449     }
15450 }
15451
15452 static inline void convert_VkMicromapCreateInfoEXT_win32_to_host(const VkMicromapCreateInfoEXT32 *in, VkMicromapCreateInfoEXT *out)
15453 {
15454     if (!in) return;
15455
15456     out->sType = in->sType;
15457     out->pNext = NULL;
15458     out->createFlags = in->createFlags;
15459     out->buffer = in->buffer;
15460     out->offset = in->offset;
15461     out->size = in->size;
15462     out->type = in->type;
15463     out->deviceAddress = in->deviceAddress;
15464     if (in->pNext)
15465         FIXME("Unexpected pNext\n");
15466 }
15467
15468 static inline void convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkOpticalFlowSessionCreateInfoNV32 *in, VkOpticalFlowSessionCreateInfoNV *out)
15469 {
15470     const VkBaseInStructure32 *in_header;
15471     VkBaseOutStructure *out_header = (void *)out;
15472
15473     if (!in) return;
15474
15475     out->sType = in->sType;
15476     out->pNext = NULL;
15477     out->width = in->width;
15478     out->height = in->height;
15479     out->imageFormat = in->imageFormat;
15480     out->flowVectorFormat = in->flowVectorFormat;
15481     out->costFormat = in->costFormat;
15482     out->outputGridSize = in->outputGridSize;
15483     out->hintGridSize = in->hintGridSize;
15484     out->performanceLevel = in->performanceLevel;
15485     out->flags = in->flags;
15486
15487     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15488     {
15489         switch (in_header->sType)
15490         {
15491         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV:
15492         {
15493             VkOpticalFlowSessionCreatePrivateDataInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15494             const VkOpticalFlowSessionCreatePrivateDataInfoNV32 *in_ext = (const VkOpticalFlowSessionCreatePrivateDataInfoNV32 *)in_header;
15495             out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV;
15496             out_ext->pNext = NULL;
15497             out_ext->id = in_ext->id;
15498             out_ext->size = in_ext->size;
15499             out_ext->pPrivateData = (const void *)UlongToPtr(in_ext->pPrivateData);
15500             out_header->pNext = (void *)out_ext;
15501             out_header = (void *)out_ext;
15502             break;
15503         }
15504         default:
15505             FIXME("Unhandled sType %u.\n", in_header->sType);
15506             break;
15507         }
15508     }
15509 }
15510
15511 static inline void convert_VkPipelineCacheCreateInfo_win32_to_host(const VkPipelineCacheCreateInfo32 *in, VkPipelineCacheCreateInfo *out)
15512 {
15513     if (!in) return;
15514
15515     out->sType = in->sType;
15516     out->pNext = NULL;
15517     out->flags = in->flags;
15518     out->initialDataSize = in->initialDataSize;
15519     out->pInitialData = (const void *)UlongToPtr(in->pInitialData);
15520     if (in->pNext)
15521         FIXME("Unexpected pNext\n");
15522 }
15523
15524 static inline void convert_VkPipelineLayoutCreateInfo_win32_to_host(const VkPipelineLayoutCreateInfo32 *in, VkPipelineLayoutCreateInfo *out)
15525 {
15526     if (!in) return;
15527
15528     out->sType = in->sType;
15529     out->pNext = NULL;
15530     out->flags = in->flags;
15531     out->setLayoutCount = in->setLayoutCount;
15532     out->pSetLayouts = (const VkDescriptorSetLayout *)UlongToPtr(in->pSetLayouts);
15533     out->pushConstantRangeCount = in->pushConstantRangeCount;
15534     out->pPushConstantRanges = (const VkPushConstantRange *)UlongToPtr(in->pPushConstantRanges);
15535     if (in->pNext)
15536         FIXME("Unexpected pNext\n");
15537 }
15538
15539 static inline void convert_VkPrivateDataSlotCreateInfo_win32_to_host(const VkPrivateDataSlotCreateInfo32 *in, VkPrivateDataSlotCreateInfo *out)
15540 {
15541     if (!in) return;
15542
15543     out->sType = in->sType;
15544     out->pNext = NULL;
15545     out->flags = in->flags;
15546     if (in->pNext)
15547         FIXME("Unexpected pNext\n");
15548 }
15549
15550 static inline void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkQueryPoolCreateInfo32 *in, VkQueryPoolCreateInfo *out)
15551 {
15552     const VkBaseInStructure32 *in_header;
15553     VkBaseOutStructure *out_header = (void *)out;
15554
15555     if (!in) return;
15556
15557     out->sType = in->sType;
15558     out->pNext = NULL;
15559     out->flags = in->flags;
15560     out->queryType = in->queryType;
15561     out->queryCount = in->queryCount;
15562     out->pipelineStatistics = in->pipelineStatistics;
15563
15564     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15565     {
15566         switch (in_header->sType)
15567         {
15568         case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
15569         {
15570             VkQueryPoolPerformanceCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15571             const VkQueryPoolPerformanceCreateInfoKHR32 *in_ext = (const VkQueryPoolPerformanceCreateInfoKHR32 *)in_header;
15572             out_ext->sType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR;
15573             out_ext->pNext = NULL;
15574             out_ext->queueFamilyIndex = in_ext->queueFamilyIndex;
15575             out_ext->counterIndexCount = in_ext->counterIndexCount;
15576             out_ext->pCounterIndices = (const uint32_t *)UlongToPtr(in_ext->pCounterIndices);
15577             out_header->pNext = (void *)out_ext;
15578             out_header = (void *)out_ext;
15579             break;
15580         }
15581         case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
15582         {
15583             VkQueryPoolPerformanceQueryCreateInfoINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15584             const VkQueryPoolPerformanceQueryCreateInfoINTEL32 *in_ext = (const VkQueryPoolPerformanceQueryCreateInfoINTEL32 *)in_header;
15585             out_ext->sType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL;
15586             out_ext->pNext = NULL;
15587             out_ext->performanceCountersSampling = in_ext->performanceCountersSampling;
15588             out_header->pNext = (void *)out_ext;
15589             out_header = (void *)out_ext;
15590             break;
15591         }
15592         default:
15593             FIXME("Unhandled sType %u.\n", in_header->sType);
15594             break;
15595         }
15596     }
15597 }
15598
15599 static inline void convert_VkRayTracingShaderGroupCreateInfoKHR_win32_to_host(const VkRayTracingShaderGroupCreateInfoKHR32 *in, VkRayTracingShaderGroupCreateInfoKHR *out)
15600 {
15601     if (!in) return;
15602
15603     out->sType = in->sType;
15604     out->pNext = NULL;
15605     out->type = in->type;
15606     out->generalShader = in->generalShader;
15607     out->closestHitShader = in->closestHitShader;
15608     out->anyHitShader = in->anyHitShader;
15609     out->intersectionShader = in->intersectionShader;
15610     out->pShaderGroupCaptureReplayHandle = (const void *)UlongToPtr(in->pShaderGroupCaptureReplayHandle);
15611     if (in->pNext)
15612         FIXME("Unexpected pNext\n");
15613 }
15614
15615 static inline const VkRayTracingShaderGroupCreateInfoKHR *convert_VkRayTracingShaderGroupCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingShaderGroupCreateInfoKHR32 *in, uint32_t count)
15616 {
15617     VkRayTracingShaderGroupCreateInfoKHR *out;
15618     unsigned int i;
15619
15620     if (!in || !count) return NULL;
15621
15622     out = conversion_context_alloc(ctx, count * sizeof(*out));
15623     for (i = 0; i < count; i++)
15624     {
15625         convert_VkRayTracingShaderGroupCreateInfoKHR_win32_to_host(&in[i], &out[i]);
15626     }
15627
15628     return out;
15629 }
15630
15631 static inline void convert_VkPipelineLibraryCreateInfoKHR_win32_to_host(const VkPipelineLibraryCreateInfoKHR32 *in, VkPipelineLibraryCreateInfoKHR *out)
15632 {
15633     if (!in) return;
15634
15635     out->sType = in->sType;
15636     out->pNext = NULL;
15637     out->libraryCount = in->libraryCount;
15638     out->pLibraries = (const VkPipeline *)UlongToPtr(in->pLibraries);
15639     if (in->pNext)
15640         FIXME("Unexpected pNext\n");
15641 }
15642
15643 static inline const VkPipelineLibraryCreateInfoKHR *convert_VkPipelineLibraryCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineLibraryCreateInfoKHR32 *in, uint32_t count)
15644 {
15645     VkPipelineLibraryCreateInfoKHR *out;
15646     unsigned int i;
15647
15648     if (!in || !count) return NULL;
15649
15650     out = conversion_context_alloc(ctx, count * sizeof(*out));
15651     for (i = 0; i < count; i++)
15652     {
15653         convert_VkPipelineLibraryCreateInfoKHR_win32_to_host(&in[i], &out[i]);
15654     }
15655
15656     return out;
15657 }
15658
15659 static inline void convert_VkRayTracingPipelineInterfaceCreateInfoKHR_win32_to_host(const VkRayTracingPipelineInterfaceCreateInfoKHR32 *in, VkRayTracingPipelineInterfaceCreateInfoKHR *out)
15660 {
15661     if (!in) return;
15662
15663     out->sType = in->sType;
15664     out->pNext = NULL;
15665     out->maxPipelineRayPayloadSize = in->maxPipelineRayPayloadSize;
15666     out->maxPipelineRayHitAttributeSize = in->maxPipelineRayHitAttributeSize;
15667     if (in->pNext)
15668         FIXME("Unexpected pNext\n");
15669 }
15670
15671 static inline const VkRayTracingPipelineInterfaceCreateInfoKHR *convert_VkRayTracingPipelineInterfaceCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineInterfaceCreateInfoKHR32 *in, uint32_t count)
15672 {
15673     VkRayTracingPipelineInterfaceCreateInfoKHR *out;
15674     unsigned int i;
15675
15676     if (!in || !count) return NULL;
15677
15678     out = conversion_context_alloc(ctx, count * sizeof(*out));
15679     for (i = 0; i < count; i++)
15680     {
15681         convert_VkRayTracingPipelineInterfaceCreateInfoKHR_win32_to_host(&in[i], &out[i]);
15682     }
15683
15684     return out;
15685 }
15686
15687 #ifdef _WIN64
15688 static inline void convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, VkRayTracingPipelineCreateInfoKHR *out)
15689 {
15690     if (!in) return;
15691
15692     out->sType = in->sType;
15693     out->pNext = in->pNext;
15694     out->flags = in->flags;
15695     out->stageCount = in->stageCount;
15696     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
15697     out->groupCount = in->groupCount;
15698     out->pGroups = in->pGroups;
15699     out->maxPipelineRayRecursionDepth = in->maxPipelineRayRecursionDepth;
15700     out->pLibraryInfo = in->pLibraryInfo;
15701     out->pLibraryInterface = in->pLibraryInterface;
15702     out->pDynamicState = in->pDynamicState;
15703     out->layout = in->layout;
15704     out->basePipelineHandle = in->basePipelineHandle;
15705     out->basePipelineIndex = in->basePipelineIndex;
15706 }
15707 #endif /* _WIN64 */
15708
15709 static inline void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, VkRayTracingPipelineCreateInfoKHR *out)
15710 {
15711     const VkBaseInStructure32 *in_header;
15712     VkBaseOutStructure *out_header = (void *)out;
15713
15714     if (!in) return;
15715
15716     out->sType = in->sType;
15717     out->pNext = NULL;
15718     out->flags = in->flags;
15719     out->stageCount = in->stageCount;
15720     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
15721     out->groupCount = in->groupCount;
15722     out->pGroups = convert_VkRayTracingShaderGroupCreateInfoKHR_array_win32_to_host(ctx, (const VkRayTracingShaderGroupCreateInfoKHR32 *)UlongToPtr(in->pGroups), in->groupCount);
15723     out->maxPipelineRayRecursionDepth = in->maxPipelineRayRecursionDepth;
15724     out->pLibraryInfo = convert_VkPipelineLibraryCreateInfoKHR_array_win32_to_host(ctx, (const VkPipelineLibraryCreateInfoKHR32 *)UlongToPtr(in->pLibraryInfo), 1);
15725     out->pLibraryInterface = convert_VkRayTracingPipelineInterfaceCreateInfoKHR_array_win32_to_host(ctx, (const VkRayTracingPipelineInterfaceCreateInfoKHR32 *)UlongToPtr(in->pLibraryInterface), 1);
15726     out->pDynamicState = convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineDynamicStateCreateInfo32 *)UlongToPtr(in->pDynamicState), 1);
15727     out->layout = in->layout;
15728     out->basePipelineHandle = in->basePipelineHandle;
15729     out->basePipelineIndex = in->basePipelineIndex;
15730
15731     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15732     {
15733         switch (in_header->sType)
15734         {
15735         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
15736         {
15737             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15738             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
15739             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
15740             out_ext->pNext = NULL;
15741             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
15742             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
15743             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
15744             out_header->pNext = (void *)out_ext;
15745             out_header = (void *)out_ext;
15746             break;
15747         }
15748         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
15749         {
15750             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15751             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
15752             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
15753             out_ext->pNext = NULL;
15754             out_ext->storageBuffers = in_ext->storageBuffers;
15755             out_ext->uniformBuffers = in_ext->uniformBuffers;
15756             out_ext->vertexInputs = in_ext->vertexInputs;
15757             out_ext->images = in_ext->images;
15758             out_header->pNext = (void *)out_ext;
15759             out_header = (void *)out_ext;
15760             break;
15761         }
15762         default:
15763             FIXME("Unhandled sType %u.\n", in_header->sType);
15764             break;
15765         }
15766     }
15767 }
15768
15769 static inline void convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out)
15770 {
15771     const VkBaseInStructure *in_header;
15772     VkBaseOutStructure32 *out_header = (void *)out;
15773
15774     if (!in) return;
15775
15776
15777     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
15778     {
15779         switch (in_header->sType)
15780         {
15781         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
15782         {
15783             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
15784             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
15785             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
15786             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
15787             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
15788             out_header = (void *)out_ext;
15789             break;
15790         }
15791         default:
15792             break;
15793         }
15794     }
15795 }
15796
15797 #ifdef _WIN64
15798 static inline const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, uint32_t count)
15799 {
15800     VkRayTracingPipelineCreateInfoKHR *out;
15801     unsigned int i;
15802
15803     if (!in || !count) return NULL;
15804
15805     out = conversion_context_alloc(ctx, count * sizeof(*out));
15806     for (i = 0; i < count; i++)
15807     {
15808         convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(ctx, &in[i], &out[i]);
15809     }
15810
15811     return out;
15812 }
15813 #endif /* _WIN64 */
15814
15815 static inline const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, uint32_t count)
15816 {
15817     VkRayTracingPipelineCreateInfoKHR *out;
15818     unsigned int i;
15819
15820     if (!in || !count) return NULL;
15821
15822     out = conversion_context_alloc(ctx, count * sizeof(*out));
15823     for (i = 0; i < count; i++)
15824     {
15825         convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(ctx, &in[i], &out[i]);
15826     }
15827
15828     return out;
15829 }
15830
15831 static inline void convert_VkRayTracingPipelineCreateInfoKHR_array_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out, uint32_t count)
15832 {
15833     unsigned int i;
15834
15835     if (!in) return;
15836
15837     for (i = 0; i < count; i++)
15838     {
15839         convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(&in[i], &out[i]);
15840     }
15841 }
15842
15843 static inline void convert_VkRayTracingShaderGroupCreateInfoNV_win32_to_host(const VkRayTracingShaderGroupCreateInfoNV32 *in, VkRayTracingShaderGroupCreateInfoNV *out)
15844 {
15845     if (!in) return;
15846
15847     out->sType = in->sType;
15848     out->pNext = NULL;
15849     out->type = in->type;
15850     out->generalShader = in->generalShader;
15851     out->closestHitShader = in->closestHitShader;
15852     out->anyHitShader = in->anyHitShader;
15853     out->intersectionShader = in->intersectionShader;
15854     if (in->pNext)
15855         FIXME("Unexpected pNext\n");
15856 }
15857
15858 static inline const VkRayTracingShaderGroupCreateInfoNV *convert_VkRayTracingShaderGroupCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingShaderGroupCreateInfoNV32 *in, uint32_t count)
15859 {
15860     VkRayTracingShaderGroupCreateInfoNV *out;
15861     unsigned int i;
15862
15863     if (!in || !count) return NULL;
15864
15865     out = conversion_context_alloc(ctx, count * sizeof(*out));
15866     for (i = 0; i < count; i++)
15867     {
15868         convert_VkRayTracingShaderGroupCreateInfoNV_win32_to_host(&in[i], &out[i]);
15869     }
15870
15871     return out;
15872 }
15873
15874 #ifdef _WIN64
15875 static inline void convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, VkRayTracingPipelineCreateInfoNV *out)
15876 {
15877     if (!in) return;
15878
15879     out->sType = in->sType;
15880     out->pNext = in->pNext;
15881     out->flags = in->flags;
15882     out->stageCount = in->stageCount;
15883     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
15884     out->groupCount = in->groupCount;
15885     out->pGroups = in->pGroups;
15886     out->maxRecursionDepth = in->maxRecursionDepth;
15887     out->layout = in->layout;
15888     out->basePipelineHandle = in->basePipelineHandle;
15889     out->basePipelineIndex = in->basePipelineIndex;
15890 }
15891 #endif /* _WIN64 */
15892
15893 static inline void convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, VkRayTracingPipelineCreateInfoNV *out)
15894 {
15895     const VkBaseInStructure32 *in_header;
15896     VkBaseOutStructure *out_header = (void *)out;
15897
15898     if (!in) return;
15899
15900     out->sType = in->sType;
15901     out->pNext = NULL;
15902     out->flags = in->flags;
15903     out->stageCount = in->stageCount;
15904     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
15905     out->groupCount = in->groupCount;
15906     out->pGroups = convert_VkRayTracingShaderGroupCreateInfoNV_array_win32_to_host(ctx, (const VkRayTracingShaderGroupCreateInfoNV32 *)UlongToPtr(in->pGroups), in->groupCount);
15907     out->maxRecursionDepth = in->maxRecursionDepth;
15908     out->layout = in->layout;
15909     out->basePipelineHandle = in->basePipelineHandle;
15910     out->basePipelineIndex = in->basePipelineIndex;
15911
15912     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15913     {
15914         switch (in_header->sType)
15915         {
15916         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
15917         {
15918             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15919             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
15920             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
15921             out_ext->pNext = NULL;
15922             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
15923             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
15924             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
15925             out_header->pNext = (void *)out_ext;
15926             out_header = (void *)out_ext;
15927             break;
15928         }
15929         default:
15930             FIXME("Unhandled sType %u.\n", in_header->sType);
15931             break;
15932         }
15933     }
15934 }
15935
15936 static inline void convert_VkRayTracingPipelineCreateInfoNV_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out)
15937 {
15938     const VkBaseInStructure *in_header;
15939     VkBaseOutStructure32 *out_header = (void *)out;
15940
15941     if (!in) return;
15942
15943
15944     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
15945     {
15946         switch (in_header->sType)
15947         {
15948         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
15949         {
15950             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
15951             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
15952             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
15953             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
15954             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
15955             out_header = (void *)out_ext;
15956             break;
15957         }
15958         default:
15959             break;
15960         }
15961     }
15962 }
15963
15964 #ifdef _WIN64
15965 static inline const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, uint32_t count)
15966 {
15967     VkRayTracingPipelineCreateInfoNV *out;
15968     unsigned int i;
15969
15970     if (!in || !count) return NULL;
15971
15972     out = conversion_context_alloc(ctx, count * sizeof(*out));
15973     for (i = 0; i < count; i++)
15974     {
15975         convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]);
15976     }
15977
15978     return out;
15979 }
15980 #endif /* _WIN64 */
15981
15982 static inline const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, uint32_t count)
15983 {
15984     VkRayTracingPipelineCreateInfoNV *out;
15985     unsigned int i;
15986
15987     if (!in || !count) return NULL;
15988
15989     out = conversion_context_alloc(ctx, count * sizeof(*out));
15990     for (i = 0; i < count; i++)
15991     {
15992         convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]);
15993     }
15994
15995     return out;
15996 }
15997
15998 static inline void convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out, uint32_t count)
15999 {
16000     unsigned int i;
16001
16002     if (!in) return;
16003
16004     for (i = 0; i < count; i++)
16005     {
16006         convert_VkRayTracingPipelineCreateInfoNV_host_to_win32(&in[i], &out[i]);
16007     }
16008 }
16009
16010 static inline void convert_VkSubpassDescription_win32_to_host(const VkSubpassDescription32 *in, VkSubpassDescription *out)
16011 {
16012     if (!in) return;
16013
16014     out->flags = in->flags;
16015     out->pipelineBindPoint = in->pipelineBindPoint;
16016     out->inputAttachmentCount = in->inputAttachmentCount;
16017     out->pInputAttachments = (const VkAttachmentReference *)UlongToPtr(in->pInputAttachments);
16018     out->colorAttachmentCount = in->colorAttachmentCount;
16019     out->pColorAttachments = (const VkAttachmentReference *)UlongToPtr(in->pColorAttachments);
16020     out->pResolveAttachments = (const VkAttachmentReference *)UlongToPtr(in->pResolveAttachments);
16021     out->pDepthStencilAttachment = (const VkAttachmentReference *)UlongToPtr(in->pDepthStencilAttachment);
16022     out->preserveAttachmentCount = in->preserveAttachmentCount;
16023     out->pPreserveAttachments = (const uint32_t *)UlongToPtr(in->pPreserveAttachments);
16024 }
16025
16026 static inline const VkSubpassDescription *convert_VkSubpassDescription_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription32 *in, uint32_t count)
16027 {
16028     VkSubpassDescription *out;
16029     unsigned int i;
16030
16031     if (!in || !count) return NULL;
16032
16033     out = conversion_context_alloc(ctx, count * sizeof(*out));
16034     for (i = 0; i < count; i++)
16035     {
16036         convert_VkSubpassDescription_win32_to_host(&in[i], &out[i]);
16037     }
16038
16039     return out;
16040 }
16041
16042 static inline void convert_VkRenderPassCreateInfo_win32_to_host(struct conversion_context *ctx, const VkRenderPassCreateInfo32 *in, VkRenderPassCreateInfo *out)
16043 {
16044     const VkBaseInStructure32 *in_header;
16045     VkBaseOutStructure *out_header = (void *)out;
16046
16047     if (!in) return;
16048
16049     out->sType = in->sType;
16050     out->pNext = NULL;
16051     out->flags = in->flags;
16052     out->attachmentCount = in->attachmentCount;
16053     out->pAttachments = (const VkAttachmentDescription *)UlongToPtr(in->pAttachments);
16054     out->subpassCount = in->subpassCount;
16055     out->pSubpasses = convert_VkSubpassDescription_array_win32_to_host(ctx, (const VkSubpassDescription32 *)UlongToPtr(in->pSubpasses), in->subpassCount);
16056     out->dependencyCount = in->dependencyCount;
16057     out->pDependencies = (const VkSubpassDependency *)UlongToPtr(in->pDependencies);
16058
16059     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16060     {
16061         switch (in_header->sType)
16062         {
16063         case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
16064         {
16065             VkRenderPassMultiviewCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16066             const VkRenderPassMultiviewCreateInfo32 *in_ext = (const VkRenderPassMultiviewCreateInfo32 *)in_header;
16067             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO;
16068             out_ext->pNext = NULL;
16069             out_ext->subpassCount = in_ext->subpassCount;
16070             out_ext->pViewMasks = (const uint32_t *)UlongToPtr(in_ext->pViewMasks);
16071             out_ext->dependencyCount = in_ext->dependencyCount;
16072             out_ext->pViewOffsets = (const int32_t *)UlongToPtr(in_ext->pViewOffsets);
16073             out_ext->correlationMaskCount = in_ext->correlationMaskCount;
16074             out_ext->pCorrelationMasks = (const uint32_t *)UlongToPtr(in_ext->pCorrelationMasks);
16075             out_header->pNext = (void *)out_ext;
16076             out_header = (void *)out_ext;
16077             break;
16078         }
16079         case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
16080         {
16081             VkRenderPassInputAttachmentAspectCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16082             const VkRenderPassInputAttachmentAspectCreateInfo32 *in_ext = (const VkRenderPassInputAttachmentAspectCreateInfo32 *)in_header;
16083             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO;
16084             out_ext->pNext = NULL;
16085             out_ext->aspectReferenceCount = in_ext->aspectReferenceCount;
16086             out_ext->pAspectReferences = (const VkInputAttachmentAspectReference *)UlongToPtr(in_ext->pAspectReferences);
16087             out_header->pNext = (void *)out_ext;
16088             out_header = (void *)out_ext;
16089             break;
16090         }
16091         case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
16092         {
16093             VkRenderPassFragmentDensityMapCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16094             const VkRenderPassFragmentDensityMapCreateInfoEXT32 *in_ext = (const VkRenderPassFragmentDensityMapCreateInfoEXT32 *)in_header;
16095             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
16096             out_ext->pNext = NULL;
16097             out_ext->fragmentDensityMapAttachment = in_ext->fragmentDensityMapAttachment;
16098             out_header->pNext = (void *)out_ext;
16099             out_header = (void *)out_ext;
16100             break;
16101         }
16102         default:
16103             FIXME("Unhandled sType %u.\n", in_header->sType);
16104             break;
16105         }
16106     }
16107 }
16108
16109 static inline void convert_VkAttachmentDescription2_win32_to_host(struct conversion_context *ctx, const VkAttachmentDescription232 *in, VkAttachmentDescription2 *out)
16110 {
16111     const VkBaseInStructure32 *in_header;
16112     VkBaseOutStructure *out_header = (void *)out;
16113
16114     if (!in) return;
16115
16116     out->sType = in->sType;
16117     out->pNext = NULL;
16118     out->flags = in->flags;
16119     out->format = in->format;
16120     out->samples = in->samples;
16121     out->loadOp = in->loadOp;
16122     out->storeOp = in->storeOp;
16123     out->stencilLoadOp = in->stencilLoadOp;
16124     out->stencilStoreOp = in->stencilStoreOp;
16125     out->initialLayout = in->initialLayout;
16126     out->finalLayout = in->finalLayout;
16127
16128     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16129     {
16130         switch (in_header->sType)
16131         {
16132         case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
16133         {
16134             VkAttachmentDescriptionStencilLayout *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16135             const VkAttachmentDescriptionStencilLayout32 *in_ext = (const VkAttachmentDescriptionStencilLayout32 *)in_header;
16136             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT;
16137             out_ext->pNext = NULL;
16138             out_ext->stencilInitialLayout = in_ext->stencilInitialLayout;
16139             out_ext->stencilFinalLayout = in_ext->stencilFinalLayout;
16140             out_header->pNext = (void *)out_ext;
16141             out_header = (void *)out_ext;
16142             break;
16143         }
16144         default:
16145             FIXME("Unhandled sType %u.\n", in_header->sType);
16146             break;
16147         }
16148     }
16149 }
16150
16151 static inline const VkAttachmentDescription2 *convert_VkAttachmentDescription2_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentDescription232 *in, uint32_t count)
16152 {
16153     VkAttachmentDescription2 *out;
16154     unsigned int i;
16155
16156     if (!in || !count) return NULL;
16157
16158     out = conversion_context_alloc(ctx, count * sizeof(*out));
16159     for (i = 0; i < count; i++)
16160     {
16161         convert_VkAttachmentDescription2_win32_to_host(ctx, &in[i], &out[i]);
16162     }
16163
16164     return out;
16165 }
16166
16167 static inline void convert_VkAttachmentReference2_win32_to_host(struct conversion_context *ctx, const VkAttachmentReference232 *in, VkAttachmentReference2 *out)
16168 {
16169     const VkBaseInStructure32 *in_header;
16170     VkBaseOutStructure *out_header = (void *)out;
16171
16172     if (!in) return;
16173
16174     out->sType = in->sType;
16175     out->pNext = NULL;
16176     out->attachment = in->attachment;
16177     out->layout = in->layout;
16178     out->aspectMask = in->aspectMask;
16179
16180     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16181     {
16182         switch (in_header->sType)
16183         {
16184         case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
16185         {
16186             VkAttachmentReferenceStencilLayout *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16187             const VkAttachmentReferenceStencilLayout32 *in_ext = (const VkAttachmentReferenceStencilLayout32 *)in_header;
16188             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT;
16189             out_ext->pNext = NULL;
16190             out_ext->stencilLayout = in_ext->stencilLayout;
16191             out_header->pNext = (void *)out_ext;
16192             out_header = (void *)out_ext;
16193             break;
16194         }
16195         default:
16196             FIXME("Unhandled sType %u.\n", in_header->sType);
16197             break;
16198         }
16199     }
16200 }
16201
16202 static inline const VkAttachmentReference2 *convert_VkAttachmentReference2_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentReference232 *in, uint32_t count)
16203 {
16204     VkAttachmentReference2 *out;
16205     unsigned int i;
16206
16207     if (!in || !count) return NULL;
16208
16209     out = conversion_context_alloc(ctx, count * sizeof(*out));
16210     for (i = 0; i < count; i++)
16211     {
16212         convert_VkAttachmentReference2_win32_to_host(ctx, &in[i], &out[i]);
16213     }
16214
16215     return out;
16216 }
16217
16218 static inline void convert_VkSubpassDescription2_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription232 *in, VkSubpassDescription2 *out)
16219 {
16220     const VkBaseInStructure32 *in_header;
16221     VkBaseOutStructure *out_header = (void *)out;
16222
16223     if (!in) return;
16224
16225     out->sType = in->sType;
16226     out->pNext = NULL;
16227     out->flags = in->flags;
16228     out->pipelineBindPoint = in->pipelineBindPoint;
16229     out->viewMask = in->viewMask;
16230     out->inputAttachmentCount = in->inputAttachmentCount;
16231     out->pInputAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pInputAttachments), in->inputAttachmentCount);
16232     out->colorAttachmentCount = in->colorAttachmentCount;
16233     out->pColorAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pColorAttachments), in->colorAttachmentCount);
16234     out->pResolveAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pResolveAttachments), in->colorAttachmentCount);
16235     out->pDepthStencilAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pDepthStencilAttachment), 1);
16236     out->preserveAttachmentCount = in->preserveAttachmentCount;
16237     out->pPreserveAttachments = (const uint32_t *)UlongToPtr(in->pPreserveAttachments);
16238
16239     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16240     {
16241         switch (in_header->sType)
16242         {
16243         case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
16244         {
16245             VkSubpassDescriptionDepthStencilResolve *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16246             const VkSubpassDescriptionDepthStencilResolve32 *in_ext = (const VkSubpassDescriptionDepthStencilResolve32 *)in_header;
16247             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
16248             out_ext->pNext = NULL;
16249             out_ext->depthResolveMode = in_ext->depthResolveMode;
16250             out_ext->stencilResolveMode = in_ext->stencilResolveMode;
16251             out_ext->pDepthStencilResolveAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in_ext->pDepthStencilResolveAttachment), 1);
16252             out_header->pNext = (void *)out_ext;
16253             out_header = (void *)out_ext;
16254             break;
16255         }
16256         case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
16257         {
16258             VkFragmentShadingRateAttachmentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16259             const VkFragmentShadingRateAttachmentInfoKHR32 *in_ext = (const VkFragmentShadingRateAttachmentInfoKHR32 *)in_header;
16260             out_ext->sType = VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
16261             out_ext->pNext = NULL;
16262             out_ext->pFragmentShadingRateAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in_ext->pFragmentShadingRateAttachment), 1);
16263             out_ext->shadingRateAttachmentTexelSize = in_ext->shadingRateAttachmentTexelSize;
16264             out_header->pNext = (void *)out_ext;
16265             out_header = (void *)out_ext;
16266             break;
16267         }
16268         case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
16269         {
16270             VkMultisampledRenderToSingleSampledInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16271             const VkMultisampledRenderToSingleSampledInfoEXT32 *in_ext = (const VkMultisampledRenderToSingleSampledInfoEXT32 *)in_header;
16272             out_ext->sType = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT;
16273             out_ext->pNext = NULL;
16274             out_ext->multisampledRenderToSingleSampledEnable = in_ext->multisampledRenderToSingleSampledEnable;
16275             out_ext->rasterizationSamples = in_ext->rasterizationSamples;
16276             out_header->pNext = (void *)out_ext;
16277             out_header = (void *)out_ext;
16278             break;
16279         }
16280         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
16281         {
16282             VkRenderPassCreationControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16283             const VkRenderPassCreationControlEXT32 *in_ext = (const VkRenderPassCreationControlEXT32 *)in_header;
16284             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT;
16285             out_ext->pNext = NULL;
16286             out_ext->disallowMerging = in_ext->disallowMerging;
16287             out_header->pNext = (void *)out_ext;
16288             out_header = (void *)out_ext;
16289             break;
16290         }
16291         case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT:
16292         {
16293             VkRenderPassSubpassFeedbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16294             const VkRenderPassSubpassFeedbackCreateInfoEXT32 *in_ext = (const VkRenderPassSubpassFeedbackCreateInfoEXT32 *)in_header;
16295             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT;
16296             out_ext->pNext = NULL;
16297             out_ext->pSubpassFeedback = (VkRenderPassSubpassFeedbackInfoEXT *)UlongToPtr(in_ext->pSubpassFeedback);
16298             out_header->pNext = (void *)out_ext;
16299             out_header = (void *)out_ext;
16300             break;
16301         }
16302         default:
16303             FIXME("Unhandled sType %u.\n", in_header->sType);
16304             break;
16305         }
16306     }
16307 }
16308
16309 static inline const VkSubpassDescription2 *convert_VkSubpassDescription2_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription232 *in, uint32_t count)
16310 {
16311     VkSubpassDescription2 *out;
16312     unsigned int i;
16313
16314     if (!in || !count) return NULL;
16315
16316     out = conversion_context_alloc(ctx, count * sizeof(*out));
16317     for (i = 0; i < count; i++)
16318     {
16319         convert_VkSubpassDescription2_win32_to_host(ctx, &in[i], &out[i]);
16320     }
16321
16322     return out;
16323 }
16324
16325 static inline void convert_VkSubpassDependency2_win32_to_host(struct conversion_context *ctx, const VkSubpassDependency232 *in, VkSubpassDependency2 *out)
16326 {
16327     const VkBaseInStructure32 *in_header;
16328     VkBaseOutStructure *out_header = (void *)out;
16329
16330     if (!in) return;
16331
16332     out->sType = in->sType;
16333     out->pNext = NULL;
16334     out->srcSubpass = in->srcSubpass;
16335     out->dstSubpass = in->dstSubpass;
16336     out->srcStageMask = in->srcStageMask;
16337     out->dstStageMask = in->dstStageMask;
16338     out->srcAccessMask = in->srcAccessMask;
16339     out->dstAccessMask = in->dstAccessMask;
16340     out->dependencyFlags = in->dependencyFlags;
16341     out->viewOffset = in->viewOffset;
16342
16343     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16344     {
16345         switch (in_header->sType)
16346         {
16347         case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
16348         {
16349             VkMemoryBarrier2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16350             const VkMemoryBarrier232 *in_ext = (const VkMemoryBarrier232 *)in_header;
16351             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2;
16352             out_ext->pNext = NULL;
16353             out_ext->srcStageMask = in_ext->srcStageMask;
16354             out_ext->srcAccessMask = in_ext->srcAccessMask;
16355             out_ext->dstStageMask = in_ext->dstStageMask;
16356             out_ext->dstAccessMask = in_ext->dstAccessMask;
16357             out_header->pNext = (void *)out_ext;
16358             out_header = (void *)out_ext;
16359             break;
16360         }
16361         default:
16362             FIXME("Unhandled sType %u.\n", in_header->sType);
16363             break;
16364         }
16365     }
16366 }
16367
16368 static inline const VkSubpassDependency2 *convert_VkSubpassDependency2_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDependency232 *in, uint32_t count)
16369 {
16370     VkSubpassDependency2 *out;
16371     unsigned int i;
16372
16373     if (!in || !count) return NULL;
16374
16375     out = conversion_context_alloc(ctx, count * sizeof(*out));
16376     for (i = 0; i < count; i++)
16377     {
16378         convert_VkSubpassDependency2_win32_to_host(ctx, &in[i], &out[i]);
16379     }
16380
16381     return out;
16382 }
16383
16384 static inline void convert_VkRenderPassCreateInfo2_win32_to_host(struct conversion_context *ctx, const VkRenderPassCreateInfo232 *in, VkRenderPassCreateInfo2 *out)
16385 {
16386     const VkBaseInStructure32 *in_header;
16387     VkBaseOutStructure *out_header = (void *)out;
16388
16389     if (!in) return;
16390
16391     out->sType = in->sType;
16392     out->pNext = NULL;
16393     out->flags = in->flags;
16394     out->attachmentCount = in->attachmentCount;
16395     out->pAttachments = convert_VkAttachmentDescription2_array_win32_to_host(ctx, (const VkAttachmentDescription232 *)UlongToPtr(in->pAttachments), in->attachmentCount);
16396     out->subpassCount = in->subpassCount;
16397     out->pSubpasses = convert_VkSubpassDescription2_array_win32_to_host(ctx, (const VkSubpassDescription232 *)UlongToPtr(in->pSubpasses), in->subpassCount);
16398     out->dependencyCount = in->dependencyCount;
16399     out->pDependencies = convert_VkSubpassDependency2_array_win32_to_host(ctx, (const VkSubpassDependency232 *)UlongToPtr(in->pDependencies), in->dependencyCount);
16400     out->correlatedViewMaskCount = in->correlatedViewMaskCount;
16401     out->pCorrelatedViewMasks = (const uint32_t *)UlongToPtr(in->pCorrelatedViewMasks);
16402
16403     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16404     {
16405         switch (in_header->sType)
16406         {
16407         case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
16408         {
16409             VkRenderPassFragmentDensityMapCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16410             const VkRenderPassFragmentDensityMapCreateInfoEXT32 *in_ext = (const VkRenderPassFragmentDensityMapCreateInfoEXT32 *)in_header;
16411             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
16412             out_ext->pNext = NULL;
16413             out_ext->fragmentDensityMapAttachment = in_ext->fragmentDensityMapAttachment;
16414             out_header->pNext = (void *)out_ext;
16415             out_header = (void *)out_ext;
16416             break;
16417         }
16418         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
16419         {
16420             VkRenderPassCreationControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16421             const VkRenderPassCreationControlEXT32 *in_ext = (const VkRenderPassCreationControlEXT32 *)in_header;
16422             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT;
16423             out_ext->pNext = NULL;
16424             out_ext->disallowMerging = in_ext->disallowMerging;
16425             out_header->pNext = (void *)out_ext;
16426             out_header = (void *)out_ext;
16427             break;
16428         }
16429         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT:
16430         {
16431             VkRenderPassCreationFeedbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16432             const VkRenderPassCreationFeedbackCreateInfoEXT32 *in_ext = (const VkRenderPassCreationFeedbackCreateInfoEXT32 *)in_header;
16433             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT;
16434             out_ext->pNext = NULL;
16435             out_ext->pRenderPassFeedback = (VkRenderPassCreationFeedbackInfoEXT *)UlongToPtr(in_ext->pRenderPassFeedback);
16436             out_header->pNext = (void *)out_ext;
16437             out_header = (void *)out_ext;
16438             break;
16439         }
16440         default:
16441             FIXME("Unhandled sType %u.\n", in_header->sType);
16442             break;
16443         }
16444     }
16445 }
16446
16447 static inline void convert_VkSamplerCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSamplerCreateInfo32 *in, VkSamplerCreateInfo *out)
16448 {
16449     const VkBaseInStructure32 *in_header;
16450     VkBaseOutStructure *out_header = (void *)out;
16451
16452     if (!in) return;
16453
16454     out->sType = in->sType;
16455     out->pNext = NULL;
16456     out->flags = in->flags;
16457     out->magFilter = in->magFilter;
16458     out->minFilter = in->minFilter;
16459     out->mipmapMode = in->mipmapMode;
16460     out->addressModeU = in->addressModeU;
16461     out->addressModeV = in->addressModeV;
16462     out->addressModeW = in->addressModeW;
16463     out->mipLodBias = in->mipLodBias;
16464     out->anisotropyEnable = in->anisotropyEnable;
16465     out->maxAnisotropy = in->maxAnisotropy;
16466     out->compareEnable = in->compareEnable;
16467     out->compareOp = in->compareOp;
16468     out->minLod = in->minLod;
16469     out->maxLod = in->maxLod;
16470     out->borderColor = in->borderColor;
16471     out->unnormalizedCoordinates = in->unnormalizedCoordinates;
16472
16473     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16474     {
16475         switch (in_header->sType)
16476         {
16477         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
16478         {
16479             VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16480             const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header;
16481             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
16482             out_ext->pNext = NULL;
16483             out_ext->conversion = in_ext->conversion;
16484             out_header->pNext = (void *)out_ext;
16485             out_header = (void *)out_ext;
16486             break;
16487         }
16488         case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
16489         {
16490             VkSamplerReductionModeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16491             const VkSamplerReductionModeCreateInfo32 *in_ext = (const VkSamplerReductionModeCreateInfo32 *)in_header;
16492             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO;
16493             out_ext->pNext = NULL;
16494             out_ext->reductionMode = in_ext->reductionMode;
16495             out_header->pNext = (void *)out_ext;
16496             out_header = (void *)out_ext;
16497             break;
16498         }
16499         case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
16500         {
16501             VkSamplerCustomBorderColorCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16502             const VkSamplerCustomBorderColorCreateInfoEXT32 *in_ext = (const VkSamplerCustomBorderColorCreateInfoEXT32 *)in_header;
16503             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT;
16504             out_ext->pNext = NULL;
16505             out_ext->customBorderColor = in_ext->customBorderColor;
16506             out_ext->format = in_ext->format;
16507             out_header->pNext = (void *)out_ext;
16508             out_header = (void *)out_ext;
16509             break;
16510         }
16511         case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
16512         {
16513             VkSamplerBorderColorComponentMappingCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16514             const VkSamplerBorderColorComponentMappingCreateInfoEXT32 *in_ext = (const VkSamplerBorderColorComponentMappingCreateInfoEXT32 *)in_header;
16515             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT;
16516             out_ext->pNext = NULL;
16517             out_ext->components = in_ext->components;
16518             out_ext->srgb = in_ext->srgb;
16519             out_header->pNext = (void *)out_ext;
16520             out_header = (void *)out_ext;
16521             break;
16522         }
16523         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
16524         {
16525             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16526             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
16527             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
16528             out_ext->pNext = NULL;
16529             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
16530             out_header->pNext = (void *)out_ext;
16531             out_header = (void *)out_ext;
16532             break;
16533         }
16534         default:
16535             FIXME("Unhandled sType %u.\n", in_header->sType);
16536             break;
16537         }
16538     }
16539 }
16540
16541 static inline void convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host(const VkSamplerYcbcrConversionCreateInfo32 *in, VkSamplerYcbcrConversionCreateInfo *out)
16542 {
16543     if (!in) return;
16544
16545     out->sType = in->sType;
16546     out->pNext = NULL;
16547     out->format = in->format;
16548     out->ycbcrModel = in->ycbcrModel;
16549     out->ycbcrRange = in->ycbcrRange;
16550     out->components = in->components;
16551     out->xChromaOffset = in->xChromaOffset;
16552     out->yChromaOffset = in->yChromaOffset;
16553     out->chromaFilter = in->chromaFilter;
16554     out->forceExplicitReconstruction = in->forceExplicitReconstruction;
16555     if (in->pNext)
16556         FIXME("Unexpected pNext\n");
16557 }
16558
16559 static inline void convert_VkSemaphoreCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSemaphoreCreateInfo32 *in, VkSemaphoreCreateInfo *out)
16560 {
16561     const VkBaseInStructure32 *in_header;
16562     VkBaseOutStructure *out_header = (void *)out;
16563
16564     if (!in) return;
16565
16566     out->sType = in->sType;
16567     out->pNext = NULL;
16568     out->flags = in->flags;
16569
16570     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16571     {
16572         switch (in_header->sType)
16573         {
16574         case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
16575         {
16576             VkExportSemaphoreCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16577             const VkExportSemaphoreCreateInfo32 *in_ext = (const VkExportSemaphoreCreateInfo32 *)in_header;
16578             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO;
16579             out_ext->pNext = NULL;
16580             out_ext->handleTypes = in_ext->handleTypes;
16581             out_header->pNext = (void *)out_ext;
16582             out_header = (void *)out_ext;
16583             break;
16584         }
16585         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
16586         {
16587             VkSemaphoreTypeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16588             const VkSemaphoreTypeCreateInfo32 *in_ext = (const VkSemaphoreTypeCreateInfo32 *)in_header;
16589             out_ext->sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
16590             out_ext->pNext = NULL;
16591             out_ext->semaphoreType = in_ext->semaphoreType;
16592             out_ext->initialValue = in_ext->initialValue;
16593             out_header->pNext = (void *)out_ext;
16594             out_header = (void *)out_ext;
16595             break;
16596         }
16597         case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
16598         {
16599             VkQueryLowLatencySupportNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16600             const VkQueryLowLatencySupportNV32 *in_ext = (const VkQueryLowLatencySupportNV32 *)in_header;
16601             out_ext->sType = VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV;
16602             out_ext->pNext = NULL;
16603             out_ext->pQueriedLowLatencyData = (void *)UlongToPtr(in_ext->pQueriedLowLatencyData);
16604             out_header->pNext = (void *)out_ext;
16605             out_header = (void *)out_ext;
16606             break;
16607         }
16608         default:
16609             FIXME("Unhandled sType %u.\n", in_header->sType);
16610             break;
16611         }
16612     }
16613 }
16614
16615 static inline void convert_VkShaderModuleCreateInfo_win32_to_host(struct conversion_context *ctx, const VkShaderModuleCreateInfo32 *in, VkShaderModuleCreateInfo *out)
16616 {
16617     const VkBaseInStructure32 *in_header;
16618     VkBaseOutStructure *out_header = (void *)out;
16619
16620     if (!in) return;
16621
16622     out->sType = in->sType;
16623     out->pNext = NULL;
16624     out->flags = in->flags;
16625     out->codeSize = in->codeSize;
16626     out->pCode = (const uint32_t *)UlongToPtr(in->pCode);
16627
16628     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16629     {
16630         switch (in_header->sType)
16631         {
16632         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
16633         {
16634             VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16635             const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header;
16636             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
16637             out_ext->pNext = NULL;
16638             out_ext->validationCache = in_ext->validationCache;
16639             out_header->pNext = (void *)out_ext;
16640             out_header = (void *)out_ext;
16641             break;
16642         }
16643         default:
16644             FIXME("Unhandled sType %u.\n", in_header->sType);
16645             break;
16646         }
16647     }
16648 }
16649
16650 static inline void convert_VkShaderCreateInfoEXT_win32_to_host(struct conversion_context *ctx, const VkShaderCreateInfoEXT32 *in, VkShaderCreateInfoEXT *out)
16651 {
16652     const VkBaseInStructure32 *in_header;
16653     VkBaseOutStructure *out_header = (void *)out;
16654
16655     if (!in) return;
16656
16657     out->sType = in->sType;
16658     out->pNext = NULL;
16659     out->flags = in->flags;
16660     out->stage = in->stage;
16661     out->nextStage = in->nextStage;
16662     out->codeType = in->codeType;
16663     out->codeSize = in->codeSize;
16664     out->pCode = (const void *)UlongToPtr(in->pCode);
16665     out->pName = (const char *)UlongToPtr(in->pName);
16666     out->setLayoutCount = in->setLayoutCount;
16667     out->pSetLayouts = (const VkDescriptorSetLayout *)UlongToPtr(in->pSetLayouts);
16668     out->pushConstantRangeCount = in->pushConstantRangeCount;
16669     out->pPushConstantRanges = (const VkPushConstantRange *)UlongToPtr(in->pPushConstantRanges);
16670     out->pSpecializationInfo = convert_VkSpecializationInfo_array_win32_to_host(ctx, (const VkSpecializationInfo32 *)UlongToPtr(in->pSpecializationInfo), 1);
16671
16672     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16673     {
16674         switch (in_header->sType)
16675         {
16676         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
16677         {
16678             VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16679             const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *in_ext = (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *)in_header;
16680             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
16681             out_ext->pNext = NULL;
16682             out_ext->requiredSubgroupSize = in_ext->requiredSubgroupSize;
16683             out_header->pNext = (void *)out_ext;
16684             out_header = (void *)out_ext;
16685             break;
16686         }
16687         default:
16688             FIXME("Unhandled sType %u.\n", in_header->sType);
16689             break;
16690         }
16691     }
16692 }
16693
16694 static inline const VkShaderCreateInfoEXT *convert_VkShaderCreateInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkShaderCreateInfoEXT32 *in, uint32_t count)
16695 {
16696     VkShaderCreateInfoEXT *out;
16697     unsigned int i;
16698
16699     if (!in || !count) return NULL;
16700
16701     out = conversion_context_alloc(ctx, count * sizeof(*out));
16702     for (i = 0; i < count; i++)
16703     {
16704         convert_VkShaderCreateInfoEXT_win32_to_host(ctx, &in[i], &out[i]);
16705     }
16706
16707     return out;
16708 }
16709
16710 #ifdef _WIN64
16711 static inline void convert_VkSwapchainCreateInfoKHR_win64_to_host(const VkSwapchainCreateInfoKHR *in, VkSwapchainCreateInfoKHR *out)
16712 {
16713     if (!in) return;
16714
16715     out->sType = in->sType;
16716     out->pNext = in->pNext;
16717     out->flags = in->flags;
16718     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
16719     out->minImageCount = in->minImageCount;
16720     out->imageFormat = in->imageFormat;
16721     out->imageColorSpace = in->imageColorSpace;
16722     out->imageExtent = in->imageExtent;
16723     out->imageArrayLayers = in->imageArrayLayers;
16724     out->imageUsage = in->imageUsage;
16725     out->imageSharingMode = in->imageSharingMode;
16726     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
16727     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
16728     out->preTransform = in->preTransform;
16729     out->compositeAlpha = in->compositeAlpha;
16730     out->presentMode = in->presentMode;
16731     out->clipped = in->clipped;
16732     out->oldSwapchain = in->oldSwapchain;
16733 }
16734 #endif /* _WIN64 */
16735
16736 static inline void convert_VkSwapchainCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkSwapchainCreateInfoKHR32 *in, VkSwapchainCreateInfoKHR *out)
16737 {
16738     const VkBaseInStructure32 *in_header;
16739     VkBaseOutStructure *out_header = (void *)out;
16740
16741     if (!in) return;
16742
16743     out->sType = in->sType;
16744     out->pNext = NULL;
16745     out->flags = in->flags;
16746     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
16747     out->minImageCount = in->minImageCount;
16748     out->imageFormat = in->imageFormat;
16749     out->imageColorSpace = in->imageColorSpace;
16750     out->imageExtent = in->imageExtent;
16751     out->imageArrayLayers = in->imageArrayLayers;
16752     out->imageUsage = in->imageUsage;
16753     out->imageSharingMode = in->imageSharingMode;
16754     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
16755     out->pQueueFamilyIndices = (const uint32_t *)UlongToPtr(in->pQueueFamilyIndices);
16756     out->preTransform = in->preTransform;
16757     out->compositeAlpha = in->compositeAlpha;
16758     out->presentMode = in->presentMode;
16759     out->clipped = in->clipped;
16760     out->oldSwapchain = in->oldSwapchain;
16761
16762     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16763     {
16764         switch (in_header->sType)
16765         {
16766         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
16767         {
16768             VkDeviceGroupSwapchainCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16769             const VkDeviceGroupSwapchainCreateInfoKHR32 *in_ext = (const VkDeviceGroupSwapchainCreateInfoKHR32 *)in_header;
16770             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR;
16771             out_ext->pNext = NULL;
16772             out_ext->modes = in_ext->modes;
16773             out_header->pNext = (void *)out_ext;
16774             out_header = (void *)out_ext;
16775             break;
16776         }
16777         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
16778         {
16779             VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16780             const VkImageFormatListCreateInfo32 *in_ext = (const VkImageFormatListCreateInfo32 *)in_header;
16781             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
16782             out_ext->pNext = NULL;
16783             out_ext->viewFormatCount = in_ext->viewFormatCount;
16784             out_ext->pViewFormats = (const VkFormat *)UlongToPtr(in_ext->pViewFormats);
16785             out_header->pNext = (void *)out_ext;
16786             out_header = (void *)out_ext;
16787             break;
16788         }
16789         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV:
16790         {
16791             VkSwapchainPresentBarrierCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16792             const VkSwapchainPresentBarrierCreateInfoNV32 *in_ext = (const VkSwapchainPresentBarrierCreateInfoNV32 *)in_header;
16793             out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV;
16794             out_ext->pNext = NULL;
16795             out_ext->presentBarrierEnable = in_ext->presentBarrierEnable;
16796             out_header->pNext = (void *)out_ext;
16797             out_header = (void *)out_ext;
16798             break;
16799         }
16800         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
16801         {
16802             VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16803             const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
16804             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
16805             out_ext->pNext = NULL;
16806             out_ext->flags = in_ext->flags;
16807             out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
16808             out_ext->pFixedRateFlags = (VkImageCompressionFixedRateFlagsEXT *)UlongToPtr(in_ext->pFixedRateFlags);
16809             out_header->pNext = (void *)out_ext;
16810             out_header = (void *)out_ext;
16811             break;
16812         }
16813         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT:
16814         {
16815             VkSwapchainPresentModesCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16816             const VkSwapchainPresentModesCreateInfoEXT32 *in_ext = (const VkSwapchainPresentModesCreateInfoEXT32 *)in_header;
16817             out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT;
16818             out_ext->pNext = NULL;
16819             out_ext->presentModeCount = in_ext->presentModeCount;
16820             out_ext->pPresentModes = (const VkPresentModeKHR *)UlongToPtr(in_ext->pPresentModes);
16821             out_header->pNext = (void *)out_ext;
16822             out_header = (void *)out_ext;
16823             break;
16824         }
16825         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT:
16826         {
16827             VkSwapchainPresentScalingCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16828             const VkSwapchainPresentScalingCreateInfoEXT32 *in_ext = (const VkSwapchainPresentScalingCreateInfoEXT32 *)in_header;
16829             out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT;
16830             out_ext->pNext = NULL;
16831             out_ext->scalingBehavior = in_ext->scalingBehavior;
16832             out_ext->presentGravityX = in_ext->presentGravityX;
16833             out_ext->presentGravityY = in_ext->presentGravityY;
16834             out_header->pNext = (void *)out_ext;
16835             out_header = (void *)out_ext;
16836             break;
16837         }
16838         default:
16839             FIXME("Unhandled sType %u.\n", in_header->sType);
16840             break;
16841         }
16842     }
16843 }
16844
16845 static inline void convert_VkValidationCacheCreateInfoEXT_win32_to_host(const VkValidationCacheCreateInfoEXT32 *in, VkValidationCacheCreateInfoEXT *out)
16846 {
16847     if (!in) return;
16848
16849     out->sType = in->sType;
16850     out->pNext = NULL;
16851     out->flags = in->flags;
16852     out->initialDataSize = in->initialDataSize;
16853     out->pInitialData = (const void *)UlongToPtr(in->pInitialData);
16854     if (in->pNext)
16855         FIXME("Unexpected pNext\n");
16856 }
16857
16858 static inline void convert_VkWin32SurfaceCreateInfoKHR_win32_to_host(const VkWin32SurfaceCreateInfoKHR32 *in, VkWin32SurfaceCreateInfoKHR *out)
16859 {
16860     if (!in) return;
16861
16862     out->sType = in->sType;
16863     out->pNext = NULL;
16864     out->flags = in->flags;
16865     out->hinstance = (HINSTANCE)UlongToPtr(in->hinstance);
16866     out->hwnd = (HWND)UlongToPtr(in->hwnd);
16867     if (in->pNext)
16868         FIXME("Unexpected pNext\n");
16869 }
16870
16871 #ifdef _WIN64
16872 static inline void convert_VkDebugMarkerObjectNameInfoEXT_win64_to_host(const VkDebugMarkerObjectNameInfoEXT *in, VkDebugMarkerObjectNameInfoEXT *out)
16873 {
16874     if (!in) return;
16875
16876     out->sType = in->sType;
16877     out->pNext = in->pNext;
16878     out->objectType = in->objectType;
16879     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
16880     out->pObjectName = in->pObjectName;
16881 }
16882 #endif /* _WIN64 */
16883
16884 static inline void convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host(const VkDebugMarkerObjectNameInfoEXT32 *in, VkDebugMarkerObjectNameInfoEXT *out)
16885 {
16886     if (!in) return;
16887
16888     out->sType = in->sType;
16889     out->pNext = NULL;
16890     out->objectType = in->objectType;
16891     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
16892     out->pObjectName = (const char *)UlongToPtr(in->pObjectName);
16893     if (in->pNext)
16894         FIXME("Unexpected pNext\n");
16895 }
16896
16897 #ifdef _WIN64
16898 static inline void convert_VkDebugMarkerObjectTagInfoEXT_win64_to_host(const VkDebugMarkerObjectTagInfoEXT *in, VkDebugMarkerObjectTagInfoEXT *out)
16899 {
16900     if (!in) return;
16901
16902     out->sType = in->sType;
16903     out->pNext = in->pNext;
16904     out->objectType = in->objectType;
16905     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
16906     out->tagName = in->tagName;
16907     out->tagSize = in->tagSize;
16908     out->pTag = in->pTag;
16909 }
16910 #endif /* _WIN64 */
16911
16912 static inline void convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host(const VkDebugMarkerObjectTagInfoEXT32 *in, VkDebugMarkerObjectTagInfoEXT *out)
16913 {
16914     if (!in) return;
16915
16916     out->sType = in->sType;
16917     out->pNext = NULL;
16918     out->objectType = in->objectType;
16919     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
16920     out->tagName = in->tagName;
16921     out->tagSize = in->tagSize;
16922     out->pTag = (const void *)UlongToPtr(in->pTag);
16923     if (in->pNext)
16924         FIXME("Unexpected pNext\n");
16925 }
16926
16927 static inline void convert_VkPhysicalDevice_array_unwrapped_host_to_win32(const VkPhysicalDevice *in, PTR32 *out, uint32_t count)
16928 {
16929     unsigned int i;
16930
16931     if (!in) return;
16932
16933     for (i = 0; i < count; i++)
16934     {
16935         out[i] = PtrToUlong(in[i]);
16936     }
16937 }
16938
16939 static inline void convert_VkPhysicalDeviceGroupProperties_win32_to_unwrapped_host(const VkPhysicalDeviceGroupProperties32 *in, VkPhysicalDeviceGroupProperties *out)
16940 {
16941     if (!in) return;
16942
16943     out->sType = in->sType;
16944     out->pNext = NULL;
16945     if (in->pNext)
16946         FIXME("Unexpected pNext\n");
16947 }
16948
16949 static inline void convert_VkPhysicalDeviceGroupProperties_unwrapped_host_to_win32(const VkPhysicalDeviceGroupProperties *in, VkPhysicalDeviceGroupProperties32 *out)
16950 {
16951     if (!in) return;
16952
16953     out->physicalDeviceCount = in->physicalDeviceCount;
16954     convert_VkPhysicalDevice_array_unwrapped_host_to_win32(in->physicalDevices, out->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE);
16955     out->subsetAllocation = in->subsetAllocation;
16956 }
16957
16958 static inline VkPhysicalDeviceGroupProperties *convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPhysicalDeviceGroupProperties32 *in, uint32_t count)
16959 {
16960     VkPhysicalDeviceGroupProperties *out;
16961     unsigned int i;
16962
16963     if (!in || !count) return NULL;
16964
16965     out = conversion_context_alloc(ctx, count * sizeof(*out));
16966     for (i = 0; i < count; i++)
16967     {
16968         convert_VkPhysicalDeviceGroupProperties_win32_to_unwrapped_host(&in[i], &out[i]);
16969     }
16970
16971     return out;
16972 }
16973
16974 static inline void convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(const VkPhysicalDeviceGroupProperties *in, VkPhysicalDeviceGroupProperties32 *out, uint32_t count)
16975 {
16976     unsigned int i;
16977
16978     if (!in) return;
16979
16980     for (i = 0; i < count; i++)
16981     {
16982         convert_VkPhysicalDeviceGroupProperties_unwrapped_host_to_win32(&in[i], &out[i]);
16983     }
16984 }
16985
16986 static inline void convert_VkPerformanceCounterKHR_win32_to_host(const VkPerformanceCounterKHR32 *in, VkPerformanceCounterKHR *out)
16987 {
16988     if (!in) return;
16989
16990     out->sType = in->sType;
16991     out->pNext = NULL;
16992     if (in->pNext)
16993         FIXME("Unexpected pNext\n");
16994 }
16995
16996 static inline void convert_VkPerformanceCounterKHR_host_to_win32(const VkPerformanceCounterKHR *in, VkPerformanceCounterKHR32 *out)
16997 {
16998     if (!in) return;
16999
17000     out->unit = in->unit;
17001     out->scope = in->scope;
17002     out->storage = in->storage;
17003     memcpy(out->uuid, in->uuid, VK_UUID_SIZE * sizeof(uint8_t));
17004 }
17005
17006 static inline VkPerformanceCounterKHR *convert_VkPerformanceCounterKHR_array_win32_to_host(struct conversion_context *ctx, const VkPerformanceCounterKHR32 *in, uint32_t count)
17007 {
17008     VkPerformanceCounterKHR *out;
17009     unsigned int i;
17010
17011     if (!in || !count) return NULL;
17012
17013     out = conversion_context_alloc(ctx, count * sizeof(*out));
17014     for (i = 0; i < count; i++)
17015     {
17016         convert_VkPerformanceCounterKHR_win32_to_host(&in[i], &out[i]);
17017     }
17018
17019     return out;
17020 }
17021
17022 static inline void convert_VkPerformanceCounterKHR_array_host_to_win32(const VkPerformanceCounterKHR *in, VkPerformanceCounterKHR32 *out, uint32_t count)
17023 {
17024     unsigned int i;
17025
17026     if (!in) return;
17027
17028     for (i = 0; i < count; i++)
17029     {
17030         convert_VkPerformanceCounterKHR_host_to_win32(&in[i], &out[i]);
17031     }
17032 }
17033
17034 static inline void convert_VkPerformanceCounterDescriptionKHR_win32_to_host(const VkPerformanceCounterDescriptionKHR32 *in, VkPerformanceCounterDescriptionKHR *out)
17035 {
17036     if (!in) return;
17037
17038     out->sType = in->sType;
17039     out->pNext = NULL;
17040     if (in->pNext)
17041         FIXME("Unexpected pNext\n");
17042 }
17043
17044 static inline void convert_VkPerformanceCounterDescriptionKHR_host_to_win32(const VkPerformanceCounterDescriptionKHR *in, VkPerformanceCounterDescriptionKHR32 *out)
17045 {
17046     if (!in) return;
17047
17048     out->flags = in->flags;
17049     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
17050     memcpy(out->category, in->category, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
17051     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
17052 }
17053
17054 static inline VkPerformanceCounterDescriptionKHR *convert_VkPerformanceCounterDescriptionKHR_array_win32_to_host(struct conversion_context *ctx, const VkPerformanceCounterDescriptionKHR32 *in, uint32_t count)
17055 {
17056     VkPerformanceCounterDescriptionKHR *out;
17057     unsigned int i;
17058
17059     if (!in || !count) return NULL;
17060
17061     out = conversion_context_alloc(ctx, count * sizeof(*out));
17062     for (i = 0; i < count; i++)
17063     {
17064         convert_VkPerformanceCounterDescriptionKHR_win32_to_host(&in[i], &out[i]);
17065     }
17066
17067     return out;
17068 }
17069
17070 static inline void convert_VkPerformanceCounterDescriptionKHR_array_host_to_win32(const VkPerformanceCounterDescriptionKHR *in, VkPerformanceCounterDescriptionKHR32 *out, uint32_t count)
17071 {
17072     unsigned int i;
17073
17074     if (!in) return;
17075
17076     for (i = 0; i < count; i++)
17077     {
17078         convert_VkPerformanceCounterDescriptionKHR_host_to_win32(&in[i], &out[i]);
17079     }
17080 }
17081
17082 #ifdef _WIN64
17083 static inline void convert_VkMappedMemoryRange_win64_to_host(const VkMappedMemoryRange *in, VkMappedMemoryRange *out)
17084 {
17085     if (!in) return;
17086
17087     out->sType = in->sType;
17088     out->pNext = in->pNext;
17089     out->memory = wine_device_memory_from_handle(in->memory)->memory;
17090     out->offset = in->offset;
17091     out->size = in->size;
17092 }
17093 #endif /* _WIN64 */
17094
17095 static inline void convert_VkMappedMemoryRange_win32_to_host(const VkMappedMemoryRange32 *in, VkMappedMemoryRange *out)
17096 {
17097     if (!in) return;
17098
17099     out->sType = in->sType;
17100     out->pNext = NULL;
17101     out->memory = wine_device_memory_from_handle(in->memory)->memory;
17102     out->offset = in->offset;
17103     out->size = in->size;
17104     if (in->pNext)
17105         FIXME("Unexpected pNext\n");
17106 }
17107
17108 #ifdef _WIN64
17109 static inline const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win64_to_host(struct conversion_context *ctx, const VkMappedMemoryRange *in, uint32_t count)
17110 {
17111     VkMappedMemoryRange *out;
17112     unsigned int i;
17113
17114     if (!in || !count) return NULL;
17115
17116     out = conversion_context_alloc(ctx, count * sizeof(*out));
17117     for (i = 0; i < count; i++)
17118     {
17119         convert_VkMappedMemoryRange_win64_to_host(&in[i], &out[i]);
17120     }
17121
17122     return out;
17123 }
17124 #endif /* _WIN64 */
17125
17126 static inline const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win32_to_host(struct conversion_context *ctx, const VkMappedMemoryRange32 *in, uint32_t count)
17127 {
17128     VkMappedMemoryRange *out;
17129     unsigned int i;
17130
17131     if (!in || !count) return NULL;
17132
17133     out = conversion_context_alloc(ctx, count * sizeof(*out));
17134     for (i = 0; i < count; i++)
17135     {
17136         convert_VkMappedMemoryRange_win32_to_host(&in[i], &out[i]);
17137     }
17138
17139     return out;
17140 }
17141
17142 static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_host(const VkAccelerationStructureBuildSizesInfoKHR32 *in, VkAccelerationStructureBuildSizesInfoKHR *out)
17143 {
17144     if (!in) return;
17145
17146     out->sType = in->sType;
17147     out->pNext = NULL;
17148     out->accelerationStructureSize = in->accelerationStructureSize;
17149     out->updateScratchSize = in->updateScratchSize;
17150     out->buildScratchSize = in->buildScratchSize;
17151     if (in->pNext)
17152         FIXME("Unexpected pNext\n");
17153 }
17154
17155 static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win32(const VkAccelerationStructureBuildSizesInfoKHR *in, VkAccelerationStructureBuildSizesInfoKHR32 *out)
17156 {
17157     if (!in) return;
17158
17159     out->accelerationStructureSize = in->accelerationStructureSize;
17160     out->updateScratchSize = in->updateScratchSize;
17161     out->buildScratchSize = in->buildScratchSize;
17162 }
17163
17164 static inline void convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_host(const VkAccelerationStructureDeviceAddressInfoKHR32 *in, VkAccelerationStructureDeviceAddressInfoKHR *out)
17165 {
17166     if (!in) return;
17167
17168     out->sType = in->sType;
17169     out->pNext = NULL;
17170     out->accelerationStructure = in->accelerationStructure;
17171     if (in->pNext)
17172         FIXME("Unexpected pNext\n");
17173 }
17174
17175 static inline void convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32_to_host(const VkAccelerationStructureMemoryRequirementsInfoNV32 *in, VkAccelerationStructureMemoryRequirementsInfoNV *out)
17176 {
17177     if (!in) return;
17178
17179     out->sType = in->sType;
17180     out->pNext = NULL;
17181     out->type = in->type;
17182     out->accelerationStructure = in->accelerationStructure;
17183     if (in->pNext)
17184         FIXME("Unexpected pNext\n");
17185 }
17186
17187 static inline void convert_VkMemoryRequirements_host_to_win32(const VkMemoryRequirements *in, VkMemoryRequirements32 *out)
17188 {
17189     if (!in) return;
17190
17191     out->size = in->size;
17192     out->alignment = in->alignment;
17193     out->memoryTypeBits = in->memoryTypeBits;
17194 }
17195
17196 static inline void convert_VkMemoryRequirements2KHR_win32_to_host(const VkMemoryRequirements2KHR32 *in, VkMemoryRequirements2KHR *out)
17197 {
17198     if (!in) return;
17199
17200     out->sType = in->sType;
17201     out->pNext = NULL;
17202     if (in->pNext)
17203         FIXME("Unexpected pNext\n");
17204 }
17205
17206 static inline void convert_VkMemoryRequirements2KHR_host_to_win32(const VkMemoryRequirements2KHR *in, VkMemoryRequirements2KHR32 *out)
17207 {
17208     if (!in) return;
17209
17210     convert_VkMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
17211 }
17212
17213 static inline void convert_VkAccelerationStructureCaptureDescriptorDataInfoEXT_win32_to_host(const VkAccelerationStructureCaptureDescriptorDataInfoEXT32 *in, VkAccelerationStructureCaptureDescriptorDataInfoEXT *out)
17214 {
17215     if (!in) return;
17216
17217     out->sType = in->sType;
17218     out->pNext = NULL;
17219     out->accelerationStructure = in->accelerationStructure;
17220     out->accelerationStructureNV = in->accelerationStructureNV;
17221     if (in->pNext)
17222         FIXME("Unexpected pNext\n");
17223 }
17224
17225 static inline void convert_VkBufferDeviceAddressInfo_win32_to_host(const VkBufferDeviceAddressInfo32 *in, VkBufferDeviceAddressInfo *out)
17226 {
17227     if (!in) return;
17228
17229     out->sType = in->sType;
17230     out->pNext = NULL;
17231     out->buffer = in->buffer;
17232     if (in->pNext)
17233         FIXME("Unexpected pNext\n");
17234 }
17235
17236 static inline void convert_VkBufferMemoryRequirementsInfo2_win32_to_host(const VkBufferMemoryRequirementsInfo232 *in, VkBufferMemoryRequirementsInfo2 *out)
17237 {
17238     if (!in) return;
17239
17240     out->sType = in->sType;
17241     out->pNext = NULL;
17242     out->buffer = in->buffer;
17243     if (in->pNext)
17244         FIXME("Unexpected pNext\n");
17245 }
17246
17247 static inline void convert_VkMemoryRequirements2_win32_to_host(struct conversion_context *ctx, const VkMemoryRequirements232 *in, VkMemoryRequirements2 *out)
17248 {
17249     const VkBaseInStructure32 *in_header;
17250     VkBaseOutStructure *out_header = (void *)out;
17251
17252     if (!in) return;
17253
17254     out->sType = in->sType;
17255     out->pNext = NULL;
17256
17257     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
17258     {
17259         switch (in_header->sType)
17260         {
17261         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
17262         {
17263             VkMemoryDedicatedRequirements *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17264             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
17265             out_ext->pNext = NULL;
17266             out_header->pNext = (void *)out_ext;
17267             out_header = (void *)out_ext;
17268             break;
17269         }
17270         default:
17271             FIXME("Unhandled sType %u.\n", in_header->sType);
17272             break;
17273         }
17274     }
17275 }
17276
17277 static inline void convert_VkMemoryRequirements2_host_to_win32(const VkMemoryRequirements2 *in, VkMemoryRequirements232 *out)
17278 {
17279     const VkBaseInStructure *in_header;
17280     VkBaseOutStructure32 *out_header = (void *)out;
17281
17282     if (!in) return;
17283
17284     convert_VkMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
17285
17286     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
17287     {
17288         switch (in_header->sType)
17289         {
17290         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
17291         {
17292             VkMemoryDedicatedRequirements32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS);
17293             const VkMemoryDedicatedRequirements *in_ext = (const VkMemoryDedicatedRequirements *)in_header;
17294             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
17295             out_ext->prefersDedicatedAllocation = in_ext->prefersDedicatedAllocation;
17296             out_ext->requiresDedicatedAllocation = in_ext->requiresDedicatedAllocation;
17297             out_header = (void *)out_ext;
17298             break;
17299         }
17300         default:
17301             break;
17302         }
17303     }
17304 }
17305
17306 static inline void convert_VkBufferCaptureDescriptorDataInfoEXT_win32_to_host(const VkBufferCaptureDescriptorDataInfoEXT32 *in, VkBufferCaptureDescriptorDataInfoEXT *out)
17307 {
17308     if (!in) return;
17309
17310     out->sType = in->sType;
17311     out->pNext = NULL;
17312     out->buffer = in->buffer;
17313     if (in->pNext)
17314         FIXME("Unexpected pNext\n");
17315 }
17316
17317 static inline void convert_VkCalibratedTimestampInfoEXT_win32_to_host(const VkCalibratedTimestampInfoEXT32 *in, VkCalibratedTimestampInfoEXT *out)
17318 {
17319     if (!in) return;
17320
17321     out->sType = in->sType;
17322     out->pNext = NULL;
17323     out->timeDomain = in->timeDomain;
17324     if (in->pNext)
17325         FIXME("Unexpected pNext\n");
17326 }
17327
17328 static inline const VkCalibratedTimestampInfoEXT *convert_VkCalibratedTimestampInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkCalibratedTimestampInfoEXT32 *in, uint32_t count)
17329 {
17330     VkCalibratedTimestampInfoEXT *out;
17331     unsigned int i;
17332
17333     if (!in || !count) return NULL;
17334
17335     out = conversion_context_alloc(ctx, count * sizeof(*out));
17336     for (i = 0; i < count; i++)
17337     {
17338         convert_VkCalibratedTimestampInfoEXT_win32_to_host(&in[i], &out[i]);
17339     }
17340
17341     return out;
17342 }
17343
17344 static inline void convert_VkDescriptorAddressInfoEXT_win32_to_host(const VkDescriptorAddressInfoEXT32 *in, VkDescriptorAddressInfoEXT *out)
17345 {
17346     if (!in) return;
17347
17348     out->sType = in->sType;
17349     out->pNext = NULL;
17350     out->address = in->address;
17351     out->range = in->range;
17352     out->format = in->format;
17353     if (in->pNext)
17354         FIXME("Unexpected pNext\n");
17355 }
17356
17357 static inline const VkDescriptorAddressInfoEXT *convert_VkDescriptorAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorAddressInfoEXT32 *in, uint32_t count)
17358 {
17359     VkDescriptorAddressInfoEXT *out;
17360     unsigned int i;
17361
17362     if (!in || !count) return NULL;
17363
17364     out = conversion_context_alloc(ctx, count * sizeof(*out));
17365     for (i = 0; i < count; i++)
17366     {
17367         convert_VkDescriptorAddressInfoEXT_win32_to_host(&in[i], &out[i]);
17368     }
17369
17370     return out;
17371 }
17372
17373 static inline void convert_VkDescriptorDataEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorDataEXT32 *in, VkDescriptorDataEXT *out, VkFlags selector)
17374 {
17375     if (!in) return;
17376
17377     if (selector == VK_DESCRIPTOR_TYPE_SAMPLER)
17378         out->pSampler = (const VkSampler *)UlongToPtr(in->pSampler);
17379     if (selector == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
17380         out->pCombinedImageSampler = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pCombinedImageSampler), 1);
17381     if (selector == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)
17382         out->pInputAttachmentImage = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pInputAttachmentImage), 1);
17383     if (selector == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE)
17384         out->pSampledImage = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pSampledImage), 1);
17385     if (selector == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
17386         out->pStorageImage = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pStorageImage), 1);
17387     if (selector == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER)
17388         out->pUniformTexelBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pUniformTexelBuffer), 1);
17389     if (selector == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER)
17390         out->pStorageTexelBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pStorageTexelBuffer), 1);
17391     if (selector == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER)
17392         out->pUniformBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pUniformBuffer), 1);
17393     if (selector == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
17394         out->pStorageBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pStorageBuffer), 1);
17395     if (selector == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR || selector == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV)
17396         out->accelerationStructure = in->accelerationStructure;
17397 }
17398
17399 static inline void convert_VkDescriptorGetInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorGetInfoEXT32 *in, VkDescriptorGetInfoEXT *out)
17400 {
17401     if (!in) return;
17402
17403     out->sType = in->sType;
17404     out->pNext = NULL;
17405     out->type = in->type;
17406     convert_VkDescriptorDataEXT_win32_to_host(ctx, &in->data, &out->data, in->type);
17407     if (in->pNext)
17408         FIXME("Unexpected pNext\n");
17409 }
17410
17411 static inline void convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host(const VkDescriptorSetBindingReferenceVALVE32 *in, VkDescriptorSetBindingReferenceVALVE *out)
17412 {
17413     if (!in) return;
17414
17415     out->sType = in->sType;
17416     out->pNext = NULL;
17417     out->descriptorSetLayout = in->descriptorSetLayout;
17418     out->binding = in->binding;
17419     if (in->pNext)
17420         FIXME("Unexpected pNext\n");
17421 }
17422
17423 static inline void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_win32_to_host(const VkDescriptorSetLayoutHostMappingInfoVALVE32 *in, VkDescriptorSetLayoutHostMappingInfoVALVE *out)
17424 {
17425     if (!in) return;
17426
17427     out->sType = in->sType;
17428     out->pNext = NULL;
17429     out->descriptorOffset = in->descriptorOffset;
17430     out->descriptorSize = in->descriptorSize;
17431     if (in->pNext)
17432         FIXME("Unexpected pNext\n");
17433 }
17434
17435 static inline void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_host_to_win32(const VkDescriptorSetLayoutHostMappingInfoVALVE *in, VkDescriptorSetLayoutHostMappingInfoVALVE32 *out)
17436 {
17437     if (!in) return;
17438
17439     out->descriptorOffset = in->descriptorOffset;
17440     out->descriptorSize = in->descriptorSize;
17441 }
17442
17443 static inline void convert_VkDescriptorSetLayoutSupport_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutSupport32 *in, VkDescriptorSetLayoutSupport *out)
17444 {
17445     const VkBaseInStructure32 *in_header;
17446     VkBaseOutStructure *out_header = (void *)out;
17447
17448     if (!in) return;
17449
17450     out->sType = in->sType;
17451     out->pNext = NULL;
17452
17453     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
17454     {
17455         switch (in_header->sType)
17456         {
17457         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
17458         {
17459             VkDescriptorSetVariableDescriptorCountLayoutSupport *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17460             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
17461             out_ext->pNext = NULL;
17462             out_header->pNext = (void *)out_ext;
17463             out_header = (void *)out_ext;
17464             break;
17465         }
17466         default:
17467             FIXME("Unhandled sType %u.\n", in_header->sType);
17468             break;
17469         }
17470     }
17471 }
17472
17473 static inline void convert_VkDescriptorSetLayoutSupport_host_to_win32(const VkDescriptorSetLayoutSupport *in, VkDescriptorSetLayoutSupport32 *out)
17474 {
17475     const VkBaseInStructure *in_header;
17476     VkBaseOutStructure32 *out_header = (void *)out;
17477
17478     if (!in) return;
17479
17480     out->supported = in->supported;
17481
17482     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
17483     {
17484         switch (in_header->sType)
17485         {
17486         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
17487         {
17488             VkDescriptorSetVariableDescriptorCountLayoutSupport32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT);
17489             const VkDescriptorSetVariableDescriptorCountLayoutSupport *in_ext = (const VkDescriptorSetVariableDescriptorCountLayoutSupport *)in_header;
17490             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
17491             out_ext->maxVariableDescriptorCount = in_ext->maxVariableDescriptorCount;
17492             out_header = (void *)out_ext;
17493             break;
17494         }
17495         default:
17496             break;
17497         }
17498     }
17499 }
17500
17501 static inline void convert_VkAccelerationStructureVersionInfoKHR_win32_to_host(const VkAccelerationStructureVersionInfoKHR32 *in, VkAccelerationStructureVersionInfoKHR *out)
17502 {
17503     if (!in) return;
17504
17505     out->sType = in->sType;
17506     out->pNext = NULL;
17507     out->pVersionData = (const uint8_t *)UlongToPtr(in->pVersionData);
17508     if (in->pNext)
17509         FIXME("Unexpected pNext\n");
17510 }
17511
17512 static inline const VkBufferCreateInfo *convert_VkBufferCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, uint32_t count)
17513 {
17514     VkBufferCreateInfo *out;
17515     unsigned int i;
17516
17517     if (!in || !count) return NULL;
17518
17519     out = conversion_context_alloc(ctx, count * sizeof(*out));
17520     for (i = 0; i < count; i++)
17521     {
17522         convert_VkBufferCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
17523     }
17524
17525     return out;
17526 }
17527
17528 static inline void convert_VkDeviceBufferMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceBufferMemoryRequirements32 *in, VkDeviceBufferMemoryRequirements *out)
17529 {
17530     if (!in) return;
17531
17532     out->sType = in->sType;
17533     out->pNext = NULL;
17534     out->pCreateInfo = convert_VkBufferCreateInfo_array_win32_to_host(ctx, (const VkBufferCreateInfo32 *)UlongToPtr(in->pCreateInfo), 1);
17535     if (in->pNext)
17536         FIXME("Unexpected pNext\n");
17537 }
17538
17539 static inline void convert_VkDeviceFaultCountsEXT_win32_to_host(const VkDeviceFaultCountsEXT32 *in, VkDeviceFaultCountsEXT *out)
17540 {
17541     if (!in) return;
17542
17543     out->sType = in->sType;
17544     out->pNext = NULL;
17545     out->addressInfoCount = in->addressInfoCount;
17546     out->vendorInfoCount = in->vendorInfoCount;
17547     out->vendorBinarySize = in->vendorBinarySize;
17548     if (in->pNext)
17549         FIXME("Unexpected pNext\n");
17550 }
17551
17552 static inline void convert_VkDeviceFaultCountsEXT_host_to_win32(const VkDeviceFaultCountsEXT *in, VkDeviceFaultCountsEXT32 *out)
17553 {
17554     if (!in) return;
17555
17556     out->addressInfoCount = in->addressInfoCount;
17557     out->vendorInfoCount = in->vendorInfoCount;
17558     out->vendorBinarySize = in->vendorBinarySize;
17559 }
17560
17561 static inline void convert_VkDeviceFaultAddressInfoEXT_win32_to_host(const VkDeviceFaultAddressInfoEXT32 *in, VkDeviceFaultAddressInfoEXT *out)
17562 {
17563     if (!in) return;
17564
17565     out->addressType = in->addressType;
17566     out->reportedAddress = in->reportedAddress;
17567     out->addressPrecision = in->addressPrecision;
17568 }
17569
17570 static inline void convert_VkDeviceFaultAddressInfoEXT_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out)
17571 {
17572     if (!in) return;
17573
17574     out->addressType = in->addressType;
17575     out->reportedAddress = in->reportedAddress;
17576     out->addressPrecision = in->addressPrecision;
17577 }
17578
17579 static inline VkDeviceFaultAddressInfoEXT *convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultAddressInfoEXT32 *in, uint32_t count)
17580 {
17581     VkDeviceFaultAddressInfoEXT *out;
17582     unsigned int i;
17583
17584     if (!in || !count) return NULL;
17585
17586     out = conversion_context_alloc(ctx, count * sizeof(*out));
17587     for (i = 0; i < count; i++)
17588     {
17589         convert_VkDeviceFaultAddressInfoEXT_win32_to_host(&in[i], &out[i]);
17590     }
17591
17592     return out;
17593 }
17594
17595 static inline void convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out, uint32_t count)
17596 {
17597     unsigned int i;
17598
17599     if (!in) return;
17600
17601     for (i = 0; i < count; i++)
17602     {
17603         convert_VkDeviceFaultAddressInfoEXT_host_to_win32(&in[i], &out[i]);
17604     }
17605 }
17606
17607 static inline void convert_VkDeviceFaultVendorInfoEXT_win32_to_host(const VkDeviceFaultVendorInfoEXT32 *in, VkDeviceFaultVendorInfoEXT *out)
17608 {
17609     if (!in) return;
17610
17611     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
17612     out->vendorFaultCode = in->vendorFaultCode;
17613     out->vendorFaultData = in->vendorFaultData;
17614 }
17615
17616 static inline void convert_VkDeviceFaultVendorInfoEXT_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out)
17617 {
17618     if (!in) return;
17619
17620     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
17621     out->vendorFaultCode = in->vendorFaultCode;
17622     out->vendorFaultData = in->vendorFaultData;
17623 }
17624
17625 static inline VkDeviceFaultVendorInfoEXT *convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultVendorInfoEXT32 *in, uint32_t count)
17626 {
17627     VkDeviceFaultVendorInfoEXT *out;
17628     unsigned int i;
17629
17630     if (!in || !count) return NULL;
17631
17632     out = conversion_context_alloc(ctx, count * sizeof(*out));
17633     for (i = 0; i < count; i++)
17634     {
17635         convert_VkDeviceFaultVendorInfoEXT_win32_to_host(&in[i], &out[i]);
17636     }
17637
17638     return out;
17639 }
17640
17641 static inline void convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out, uint32_t count)
17642 {
17643     unsigned int i;
17644
17645     if (!in) return;
17646
17647     for (i = 0; i < count; i++)
17648     {
17649         convert_VkDeviceFaultVendorInfoEXT_host_to_win32(&in[i], &out[i]);
17650     }
17651 }
17652
17653 static inline void convert_VkDeviceFaultInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultInfoEXT32 *in, VkDeviceFaultInfoEXT *out)
17654 {
17655     if (!in) return;
17656
17657     out->sType = in->sType;
17658     out->pNext = NULL;
17659     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
17660     out->pAddressInfos = convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultAddressInfoEXT32 *)UlongToPtr(in->pAddressInfos), 1);
17661     out->pVendorInfos = convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultVendorInfoEXT32 *)UlongToPtr(in->pVendorInfos), 1);
17662     out->pVendorBinaryData = (void *)UlongToPtr(in->pVendorBinaryData);
17663     if (in->pNext)
17664         FIXME("Unexpected pNext\n");
17665 }
17666
17667 static inline void convert_VkDeviceFaultInfoEXT_host_to_win32(const VkDeviceFaultInfoEXT *in, VkDeviceFaultInfoEXT32 *out)
17668 {
17669     if (!in) return;
17670
17671     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
17672     convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(in->pAddressInfos, (VkDeviceFaultAddressInfoEXT32 *)UlongToPtr(out->pAddressInfos), 1);
17673     convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(in->pVendorInfos, (VkDeviceFaultVendorInfoEXT32 *)UlongToPtr(out->pVendorInfos), 1);
17674     out->pVendorBinaryData = PtrToUlong(in->pVendorBinaryData);
17675 }
17676
17677 static inline void convert_VkDeviceGroupPresentCapabilitiesKHR_win32_to_host(const VkDeviceGroupPresentCapabilitiesKHR32 *in, VkDeviceGroupPresentCapabilitiesKHR *out)
17678 {
17679     if (!in) return;
17680
17681     out->sType = in->sType;
17682     out->pNext = NULL;
17683     if (in->pNext)
17684         FIXME("Unexpected pNext\n");
17685 }
17686
17687 static inline void convert_VkDeviceGroupPresentCapabilitiesKHR_host_to_win32(const VkDeviceGroupPresentCapabilitiesKHR *in, VkDeviceGroupPresentCapabilitiesKHR32 *out)
17688 {
17689     if (!in) return;
17690
17691     memcpy(out->presentMask, in->presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
17692     out->modes = in->modes;
17693 }
17694
17695 static inline const VkImageCreateInfo *convert_VkImageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo32 *in, uint32_t count)
17696 {
17697     VkImageCreateInfo *out;
17698     unsigned int i;
17699
17700     if (!in || !count) return NULL;
17701
17702     out = conversion_context_alloc(ctx, count * sizeof(*out));
17703     for (i = 0; i < count; i++)
17704     {
17705         convert_VkImageCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
17706     }
17707
17708     return out;
17709 }
17710
17711 static inline void convert_VkDeviceImageMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceImageMemoryRequirements32 *in, VkDeviceImageMemoryRequirements *out)
17712 {
17713     if (!in) return;
17714
17715     out->sType = in->sType;
17716     out->pNext = NULL;
17717     out->pCreateInfo = convert_VkImageCreateInfo_array_win32_to_host(ctx, (const VkImageCreateInfo32 *)UlongToPtr(in->pCreateInfo), 1);
17718     out->planeAspect = in->planeAspect;
17719     if (in->pNext)
17720         FIXME("Unexpected pNext\n");
17721 }
17722
17723 static inline void convert_VkSparseImageMemoryRequirements_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out)
17724 {
17725     if (!in) return;
17726
17727     out->formatProperties = in->formatProperties;
17728     out->imageMipTailFirstLod = in->imageMipTailFirstLod;
17729     out->imageMipTailSize = in->imageMipTailSize;
17730     out->imageMipTailOffset = in->imageMipTailOffset;
17731     out->imageMipTailStride = in->imageMipTailStride;
17732 }
17733
17734 static inline void convert_VkSparseImageMemoryRequirements2_win32_to_host(const VkSparseImageMemoryRequirements232 *in, VkSparseImageMemoryRequirements2 *out)
17735 {
17736     if (!in) return;
17737
17738     out->sType = in->sType;
17739     out->pNext = NULL;
17740     if (in->pNext)
17741         FIXME("Unexpected pNext\n");
17742 }
17743
17744 static inline void convert_VkSparseImageMemoryRequirements2_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out)
17745 {
17746     if (!in) return;
17747
17748     convert_VkSparseImageMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
17749 }
17750
17751 static inline VkSparseImageMemoryRequirements2 *convert_VkSparseImageMemoryRequirements2_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryRequirements232 *in, uint32_t count)
17752 {
17753     VkSparseImageMemoryRequirements2 *out;
17754     unsigned int i;
17755
17756     if (!in || !count) return NULL;
17757
17758     out = conversion_context_alloc(ctx, count * sizeof(*out));
17759     for (i = 0; i < count; i++)
17760     {
17761         convert_VkSparseImageMemoryRequirements2_win32_to_host(&in[i], &out[i]);
17762     }
17763
17764     return out;
17765 }
17766
17767 static inline void convert_VkSparseImageMemoryRequirements2_array_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out, uint32_t count)
17768 {
17769     unsigned int i;
17770
17771     if (!in) return;
17772
17773     for (i = 0; i < count; i++)
17774     {
17775         convert_VkSparseImageMemoryRequirements2_host_to_win32(&in[i], &out[i]);
17776     }
17777 }
17778
17779 #ifdef _WIN64
17780 static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win64_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo *in, VkDeviceMemoryOpaqueCaptureAddressInfo *out)
17781 {
17782     if (!in) return;
17783
17784     out->sType = in->sType;
17785     out->pNext = in->pNext;
17786     out->memory = wine_device_memory_from_handle(in->memory)->memory;
17787 }
17788 #endif /* _WIN64 */
17789
17790 static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo32 *in, VkDeviceMemoryOpaqueCaptureAddressInfo *out)
17791 {
17792     if (!in) return;
17793
17794     out->sType = in->sType;
17795     out->pNext = NULL;
17796     out->memory = wine_device_memory_from_handle(in->memory)->memory;
17797     if (in->pNext)
17798         FIXME("Unexpected pNext\n");
17799 }
17800
17801 static inline void convert_VkMicromapVersionInfoEXT_win32_to_host(const VkMicromapVersionInfoEXT32 *in, VkMicromapVersionInfoEXT *out)
17802 {
17803     if (!in) return;
17804
17805     out->sType = in->sType;
17806     out->pNext = NULL;
17807     out->pVersionData = (const uint8_t *)UlongToPtr(in->pVersionData);
17808     if (in->pNext)
17809         FIXME("Unexpected pNext\n");
17810 }
17811
17812 static inline void convert_VkDeviceQueueInfo2_win32_to_host(const VkDeviceQueueInfo232 *in, VkDeviceQueueInfo2 *out)
17813 {
17814     if (!in) return;
17815
17816     out->sType = in->sType;
17817     out->pNext = NULL;
17818     out->flags = in->flags;
17819     out->queueFamilyIndex = in->queueFamilyIndex;
17820     out->queueIndex = in->queueIndex;
17821     if (in->pNext)
17822         FIXME("Unexpected pNext\n");
17823 }
17824
17825 static inline void convert_VkTilePropertiesQCOM_win32_to_host(const VkTilePropertiesQCOM32 *in, VkTilePropertiesQCOM *out)
17826 {
17827     if (!in) return;
17828
17829     out->sType = in->sType;
17830     out->pNext = NULL;
17831     out->tileSize = in->tileSize;
17832     out->apronSize = in->apronSize;
17833     out->origin = in->origin;
17834     if (in->pNext)
17835         FIXME("Unexpected pNext\n");
17836 }
17837
17838 static inline void convert_VkTilePropertiesQCOM_host_to_win32(const VkTilePropertiesQCOM *in, VkTilePropertiesQCOM32 *out)
17839 {
17840     if (!in) return;
17841
17842     out->tileSize = in->tileSize;
17843     out->apronSize = in->apronSize;
17844     out->origin = in->origin;
17845 }
17846
17847 static inline VkTilePropertiesQCOM *convert_VkTilePropertiesQCOM_array_win32_to_host(struct conversion_context *ctx, const VkTilePropertiesQCOM32 *in, uint32_t count)
17848 {
17849     VkTilePropertiesQCOM *out;
17850     unsigned int i;
17851
17852     if (!in || !count) return NULL;
17853
17854     out = conversion_context_alloc(ctx, count * sizeof(*out));
17855     for (i = 0; i < count; i++)
17856     {
17857         convert_VkTilePropertiesQCOM_win32_to_host(&in[i], &out[i]);
17858     }
17859
17860     return out;
17861 }
17862
17863 static inline void convert_VkTilePropertiesQCOM_array_host_to_win32(const VkTilePropertiesQCOM *in, VkTilePropertiesQCOM32 *out, uint32_t count)
17864 {
17865     unsigned int i;
17866
17867     if (!in) return;
17868
17869     for (i = 0; i < count; i++)
17870     {
17871         convert_VkTilePropertiesQCOM_host_to_win32(&in[i], &out[i]);
17872     }
17873 }
17874
17875 static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host(const VkGeneratedCommandsMemoryRequirementsInfoNV32 *in, VkGeneratedCommandsMemoryRequirementsInfoNV *out)
17876 {
17877     if (!in) return;
17878
17879     out->sType = in->sType;
17880     out->pNext = NULL;
17881     out->pipelineBindPoint = in->pipelineBindPoint;
17882     out->pipeline = in->pipeline;
17883     out->indirectCommandsLayout = in->indirectCommandsLayout;
17884     out->maxSequencesCount = in->maxSequencesCount;
17885     if (in->pNext)
17886         FIXME("Unexpected pNext\n");
17887 }
17888
17889 static inline void convert_VkImageMemoryRequirementsInfo2_win32_to_host(struct conversion_context *ctx, const VkImageMemoryRequirementsInfo232 *in, VkImageMemoryRequirementsInfo2 *out)
17890 {
17891     const VkBaseInStructure32 *in_header;
17892     VkBaseOutStructure *out_header = (void *)out;
17893
17894     if (!in) return;
17895
17896     out->sType = in->sType;
17897     out->pNext = NULL;
17898     out->image = in->image;
17899
17900     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
17901     {
17902         switch (in_header->sType)
17903         {
17904         case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
17905         {
17906             VkImagePlaneMemoryRequirementsInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17907             const VkImagePlaneMemoryRequirementsInfo32 *in_ext = (const VkImagePlaneMemoryRequirementsInfo32 *)in_header;
17908             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO;
17909             out_ext->pNext = NULL;
17910             out_ext->planeAspect = in_ext->planeAspect;
17911             out_header->pNext = (void *)out_ext;
17912             out_header = (void *)out_ext;
17913             break;
17914         }
17915         default:
17916             FIXME("Unhandled sType %u.\n", in_header->sType);
17917             break;
17918         }
17919     }
17920 }
17921
17922 static inline void convert_VkImageCaptureDescriptorDataInfoEXT_win32_to_host(const VkImageCaptureDescriptorDataInfoEXT32 *in, VkImageCaptureDescriptorDataInfoEXT *out)
17923 {
17924     if (!in) return;
17925
17926     out->sType = in->sType;
17927     out->pNext = NULL;
17928     out->image = in->image;
17929     if (in->pNext)
17930         FIXME("Unexpected pNext\n");
17931 }
17932
17933 static inline void convert_VkSparseImageMemoryRequirements_array_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out, uint32_t count)
17934 {
17935     unsigned int i;
17936
17937     if (!in) return;
17938
17939     for (i = 0; i < count; i++)
17940     {
17941         convert_VkSparseImageMemoryRequirements_host_to_win32(&in[i], &out[i]);
17942     }
17943 }
17944
17945 static inline void convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host(const VkImageSparseMemoryRequirementsInfo232 *in, VkImageSparseMemoryRequirementsInfo2 *out)
17946 {
17947     if (!in) return;
17948
17949     out->sType = in->sType;
17950     out->pNext = NULL;
17951     out->image = in->image;
17952     if (in->pNext)
17953         FIXME("Unexpected pNext\n");
17954 }
17955
17956 static inline void convert_VkSubresourceLayout_win32_to_host(const VkSubresourceLayout32 *in, VkSubresourceLayout *out)
17957 {
17958     if (!in) return;
17959
17960     out->offset = in->offset;
17961     out->size = in->size;
17962     out->rowPitch = in->rowPitch;
17963     out->arrayPitch = in->arrayPitch;
17964     out->depthPitch = in->depthPitch;
17965 }
17966
17967 static inline void convert_VkSubresourceLayout_host_to_win32(const VkSubresourceLayout *in, VkSubresourceLayout32 *out)
17968 {
17969     if (!in) return;
17970
17971     out->offset = in->offset;
17972     out->size = in->size;
17973     out->rowPitch = in->rowPitch;
17974     out->arrayPitch = in->arrayPitch;
17975     out->depthPitch = in->depthPitch;
17976 }
17977
17978 static inline void convert_VkImageSubresource2EXT_win32_to_host(const VkImageSubresource2EXT32 *in, VkImageSubresource2EXT *out)
17979 {
17980     if (!in) return;
17981
17982     out->sType = in->sType;
17983     out->pNext = NULL;
17984     out->imageSubresource = in->imageSubresource;
17985     if (in->pNext)
17986         FIXME("Unexpected pNext\n");
17987 }
17988
17989 static inline void convert_VkSubresourceLayout2EXT_win32_to_host(struct conversion_context *ctx, const VkSubresourceLayout2EXT32 *in, VkSubresourceLayout2EXT *out)
17990 {
17991     const VkBaseInStructure32 *in_header;
17992     VkBaseOutStructure *out_header = (void *)out;
17993
17994     if (!in) return;
17995
17996     out->sType = in->sType;
17997     out->pNext = NULL;
17998
17999     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
18000     {
18001         switch (in_header->sType)
18002         {
18003         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
18004         {
18005             VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18006             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
18007             out_ext->pNext = NULL;
18008             out_header->pNext = (void *)out_ext;
18009             out_header = (void *)out_ext;
18010             break;
18011         }
18012         default:
18013             FIXME("Unhandled sType %u.\n", in_header->sType);
18014             break;
18015         }
18016     }
18017 }
18018
18019 static inline void convert_VkSubresourceLayout2EXT_host_to_win32(const VkSubresourceLayout2EXT *in, VkSubresourceLayout2EXT32 *out)
18020 {
18021     const VkBaseInStructure *in_header;
18022     VkBaseOutStructure32 *out_header = (void *)out;
18023
18024     if (!in) return;
18025
18026     convert_VkSubresourceLayout_host_to_win32(&in->subresourceLayout, &out->subresourceLayout);
18027
18028     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
18029     {
18030         switch (in_header->sType)
18031         {
18032         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
18033         {
18034             VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT);
18035             const VkImageCompressionPropertiesEXT *in_ext = (const VkImageCompressionPropertiesEXT *)in_header;
18036             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
18037             out_ext->imageCompressionFlags = in_ext->imageCompressionFlags;
18038             out_ext->imageCompressionFixedRateFlags = in_ext->imageCompressionFixedRateFlags;
18039             out_header = (void *)out_ext;
18040             break;
18041         }
18042         default:
18043             break;
18044         }
18045     }
18046 }
18047
18048 static inline void convert_VkImageViewAddressPropertiesNVX_win32_to_host(const VkImageViewAddressPropertiesNVX32 *in, VkImageViewAddressPropertiesNVX *out)
18049 {
18050     if (!in) return;
18051
18052     out->sType = in->sType;
18053     out->pNext = NULL;
18054     if (in->pNext)
18055         FIXME("Unexpected pNext\n");
18056 }
18057
18058 static inline void convert_VkImageViewAddressPropertiesNVX_host_to_win32(const VkImageViewAddressPropertiesNVX *in, VkImageViewAddressPropertiesNVX32 *out)
18059 {
18060     if (!in) return;
18061
18062     out->deviceAddress = in->deviceAddress;
18063     out->size = in->size;
18064 }
18065
18066 static inline void convert_VkImageViewHandleInfoNVX_win32_to_host(const VkImageViewHandleInfoNVX32 *in, VkImageViewHandleInfoNVX *out)
18067 {
18068     if (!in) return;
18069
18070     out->sType = in->sType;
18071     out->pNext = NULL;
18072     out->imageView = in->imageView;
18073     out->descriptorType = in->descriptorType;
18074     out->sampler = in->sampler;
18075     if (in->pNext)
18076         FIXME("Unexpected pNext\n");
18077 }
18078
18079 static inline void convert_VkImageViewCaptureDescriptorDataInfoEXT_win32_to_host(const VkImageViewCaptureDescriptorDataInfoEXT32 *in, VkImageViewCaptureDescriptorDataInfoEXT *out)
18080 {
18081     if (!in) return;
18082
18083     out->sType = in->sType;
18084     out->pNext = NULL;
18085     out->imageView = in->imageView;
18086     if (in->pNext)
18087         FIXME("Unexpected pNext\n");
18088 }
18089
18090 static inline void convert_VkMemoryHostPointerPropertiesEXT_win32_to_host(const VkMemoryHostPointerPropertiesEXT32 *in, VkMemoryHostPointerPropertiesEXT *out)
18091 {
18092     if (!in) return;
18093
18094     out->sType = in->sType;
18095     out->pNext = NULL;
18096     if (in->pNext)
18097         FIXME("Unexpected pNext\n");
18098 }
18099
18100 static inline void convert_VkMemoryHostPointerPropertiesEXT_host_to_win32(const VkMemoryHostPointerPropertiesEXT *in, VkMemoryHostPointerPropertiesEXT32 *out)
18101 {
18102     if (!in) return;
18103
18104     out->memoryTypeBits = in->memoryTypeBits;
18105 }
18106
18107 static inline void convert_VkMicromapBuildSizesInfoEXT_win32_to_host(const VkMicromapBuildSizesInfoEXT32 *in, VkMicromapBuildSizesInfoEXT *out)
18108 {
18109     if (!in) return;
18110
18111     out->sType = in->sType;
18112     out->pNext = NULL;
18113     out->micromapSize = in->micromapSize;
18114     out->buildScratchSize = in->buildScratchSize;
18115     out->discardable = in->discardable;
18116     if (in->pNext)
18117         FIXME("Unexpected pNext\n");
18118 }
18119
18120 static inline void convert_VkMicromapBuildSizesInfoEXT_host_to_win32(const VkMicromapBuildSizesInfoEXT *in, VkMicromapBuildSizesInfoEXT32 *out)
18121 {
18122     if (!in) return;
18123
18124     out->micromapSize = in->micromapSize;
18125     out->buildScratchSize = in->buildScratchSize;
18126     out->discardable = in->discardable;
18127 }
18128
18129 static inline void convert_VkPerformanceValueDataINTEL_win32_to_host(const VkPerformanceValueDataINTEL32 *in, VkPerformanceValueDataINTEL *out, VkFlags selector)
18130 {
18131     if (!in) return;
18132
18133     if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL)
18134         out->value32 = in->value32;
18135     if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL)
18136         out->value64 = in->value64;
18137     if (selector == VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL)
18138         out->valueFloat = in->valueFloat;
18139     if (selector == VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL)
18140         out->valueBool = in->valueBool;
18141     if (selector == VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL)
18142         out->valueString = (const char *)UlongToPtr(in->valueString);
18143 }
18144
18145 static inline void convert_VkPerformanceValueDataINTEL_host_to_win32(const VkPerformanceValueDataINTEL *in, VkPerformanceValueDataINTEL32 *out, VkFlags selector)
18146 {
18147     if (!in) return;
18148
18149     if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL)
18150         out->value32 = in->value32;
18151     if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL)
18152         out->value64 = in->value64;
18153     if (selector == VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL)
18154         out->valueFloat = in->valueFloat;
18155     if (selector == VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL)
18156         out->valueBool = in->valueBool;
18157 }
18158
18159 static inline void convert_VkPerformanceValueINTEL_host_to_win32(const VkPerformanceValueINTEL *in, VkPerformanceValueINTEL32 *out)
18160 {
18161     if (!in) return;
18162
18163     out->type = in->type;
18164     convert_VkPerformanceValueDataINTEL_host_to_win32(&in->data, &out->data, in->type);
18165 }
18166
18167 static inline void convert_VkCooperativeMatrixPropertiesNV_win32_to_host(const VkCooperativeMatrixPropertiesNV32 *in, VkCooperativeMatrixPropertiesNV *out)
18168 {
18169     if (!in) return;
18170
18171     out->sType = in->sType;
18172     out->pNext = NULL;
18173     if (in->pNext)
18174         FIXME("Unexpected pNext\n");
18175 }
18176
18177 static inline void convert_VkCooperativeMatrixPropertiesNV_host_to_win32(const VkCooperativeMatrixPropertiesNV *in, VkCooperativeMatrixPropertiesNV32 *out)
18178 {
18179     if (!in) return;
18180
18181     out->MSize = in->MSize;
18182     out->NSize = in->NSize;
18183     out->KSize = in->KSize;
18184     out->AType = in->AType;
18185     out->BType = in->BType;
18186     out->CType = in->CType;
18187     out->DType = in->DType;
18188     out->scope = in->scope;
18189 }
18190
18191 static inline VkCooperativeMatrixPropertiesNV *convert_VkCooperativeMatrixPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixPropertiesNV32 *in, uint32_t count)
18192 {
18193     VkCooperativeMatrixPropertiesNV *out;
18194     unsigned int i;
18195
18196     if (!in || !count) return NULL;
18197
18198     out = conversion_context_alloc(ctx, count * sizeof(*out));
18199     for (i = 0; i < count; i++)
18200     {
18201         convert_VkCooperativeMatrixPropertiesNV_win32_to_host(&in[i], &out[i]);
18202     }
18203
18204     return out;
18205 }
18206
18207 static inline void convert_VkCooperativeMatrixPropertiesNV_array_host_to_win32(const VkCooperativeMatrixPropertiesNV *in, VkCooperativeMatrixPropertiesNV32 *out, uint32_t count)
18208 {
18209     unsigned int i;
18210
18211     if (!in) return;
18212
18213     for (i = 0; i < count; i++)
18214     {
18215         convert_VkCooperativeMatrixPropertiesNV_host_to_win32(&in[i], &out[i]);
18216     }
18217 }
18218
18219 static inline void convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(const VkPhysicalDeviceExternalBufferInfo32 *in, VkPhysicalDeviceExternalBufferInfo *out)
18220 {
18221     if (!in) return;
18222
18223     out->sType = in->sType;
18224     out->pNext = NULL;
18225     out->flags = in->flags;
18226     out->usage = in->usage;
18227     out->handleType = in->handleType;
18228     if (in->pNext)
18229         FIXME("Unexpected pNext\n");
18230 }
18231
18232 static inline void convert_VkExternalBufferProperties_win32_to_host(const VkExternalBufferProperties32 *in, VkExternalBufferProperties *out)
18233 {
18234     if (!in) return;
18235
18236     out->sType = in->sType;
18237     out->pNext = NULL;
18238     if (in->pNext)
18239         FIXME("Unexpected pNext\n");
18240 }
18241
18242 static inline void convert_VkExternalBufferProperties_host_to_win32(const VkExternalBufferProperties *in, VkExternalBufferProperties32 *out)
18243 {
18244     if (!in) return;
18245
18246     out->externalMemoryProperties = in->externalMemoryProperties;
18247 }
18248
18249 static inline void convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host(const VkPhysicalDeviceExternalFenceInfo32 *in, VkPhysicalDeviceExternalFenceInfo *out)
18250 {
18251     if (!in) return;
18252
18253     out->sType = in->sType;
18254     out->pNext = NULL;
18255     out->handleType = in->handleType;
18256     if (in->pNext)
18257         FIXME("Unexpected pNext\n");
18258 }
18259
18260 static inline void convert_VkExternalFenceProperties_win32_to_host(const VkExternalFenceProperties32 *in, VkExternalFenceProperties *out)
18261 {
18262     if (!in) return;
18263
18264     out->sType = in->sType;
18265     out->pNext = NULL;
18266     if (in->pNext)
18267         FIXME("Unexpected pNext\n");
18268 }
18269
18270 static inline void convert_VkExternalFenceProperties_host_to_win32(const VkExternalFenceProperties *in, VkExternalFenceProperties32 *out)
18271 {
18272     if (!in) return;
18273
18274     out->exportFromImportedHandleTypes = in->exportFromImportedHandleTypes;
18275     out->compatibleHandleTypes = in->compatibleHandleTypes;
18276     out->externalFenceFeatures = in->externalFenceFeatures;
18277 }
18278
18279 static inline void convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalSemaphoreInfo32 *in, VkPhysicalDeviceExternalSemaphoreInfo *out)
18280 {
18281     const VkBaseInStructure32 *in_header;
18282     VkBaseOutStructure *out_header = (void *)out;
18283
18284     if (!in) return;
18285
18286     out->sType = in->sType;
18287     out->pNext = NULL;
18288     out->handleType = in->handleType;
18289
18290     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
18291     {
18292         switch (in_header->sType)
18293         {
18294         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
18295         {
18296             VkSemaphoreTypeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18297             const VkSemaphoreTypeCreateInfo32 *in_ext = (const VkSemaphoreTypeCreateInfo32 *)in_header;
18298             out_ext->sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
18299             out_ext->pNext = NULL;
18300             out_ext->semaphoreType = in_ext->semaphoreType;
18301             out_ext->initialValue = in_ext->initialValue;
18302             out_header->pNext = (void *)out_ext;
18303             out_header = (void *)out_ext;
18304             break;
18305         }
18306         default:
18307             FIXME("Unhandled sType %u.\n", in_header->sType);
18308             break;
18309         }
18310     }
18311 }
18312
18313 static inline void convert_VkExternalSemaphoreProperties_win32_to_host(const VkExternalSemaphoreProperties32 *in, VkExternalSemaphoreProperties *out)
18314 {
18315     if (!in) return;
18316
18317     out->sType = in->sType;
18318     out->pNext = NULL;
18319     if (in->pNext)
18320         FIXME("Unexpected pNext\n");
18321 }
18322
18323 static inline void convert_VkExternalSemaphoreProperties_host_to_win32(const VkExternalSemaphoreProperties *in, VkExternalSemaphoreProperties32 *out)
18324 {
18325     if (!in) return;
18326
18327     out->exportFromImportedHandleTypes = in->exportFromImportedHandleTypes;
18328     out->compatibleHandleTypes = in->compatibleHandleTypes;
18329     out->externalSemaphoreFeatures = in->externalSemaphoreFeatures;
18330 }
18331
18332 static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceFeatures232 *in, VkPhysicalDeviceFeatures2 *out)
18333 {
18334     const VkBaseInStructure32 *in_header;
18335     VkBaseOutStructure *out_header = (void *)out;
18336
18337     if (!in) return;
18338
18339     out->sType = in->sType;
18340     out->pNext = NULL;
18341     out->features = in->features;
18342
18343     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
18344     {
18345         switch (in_header->sType)
18346         {
18347         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
18348         {
18349             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18350             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *)in_header;
18351             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
18352             out_ext->pNext = NULL;
18353             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
18354             out_header->pNext = (void *)out_ext;
18355             out_header = (void *)out_ext;
18356             break;
18357         }
18358         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
18359         {
18360             VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18361             const VkPhysicalDevicePrivateDataFeatures32 *in_ext = (const VkPhysicalDevicePrivateDataFeatures32 *)in_header;
18362             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
18363             out_ext->pNext = NULL;
18364             out_ext->privateData = in_ext->privateData;
18365             out_header->pNext = (void *)out_ext;
18366             out_header = (void *)out_ext;
18367             break;
18368         }
18369         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
18370         {
18371             VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18372             const VkPhysicalDeviceVariablePointersFeatures32 *in_ext = (const VkPhysicalDeviceVariablePointersFeatures32 *)in_header;
18373             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
18374             out_ext->pNext = NULL;
18375             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
18376             out_ext->variablePointers = in_ext->variablePointers;
18377             out_header->pNext = (void *)out_ext;
18378             out_header = (void *)out_ext;
18379             break;
18380         }
18381         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
18382         {
18383             VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18384             const VkPhysicalDeviceMultiviewFeatures32 *in_ext = (const VkPhysicalDeviceMultiviewFeatures32 *)in_header;
18385             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
18386             out_ext->pNext = NULL;
18387             out_ext->multiview = in_ext->multiview;
18388             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
18389             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
18390             out_header->pNext = (void *)out_ext;
18391             out_header = (void *)out_ext;
18392             break;
18393         }
18394         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
18395         {
18396             VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18397             const VkPhysicalDevicePresentIdFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR32 *)in_header;
18398             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
18399             out_ext->pNext = NULL;
18400             out_ext->presentId = in_ext->presentId;
18401             out_header->pNext = (void *)out_ext;
18402             out_header = (void *)out_ext;
18403             break;
18404         }
18405         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
18406         {
18407             VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18408             const VkPhysicalDevicePresentWaitFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR32 *)in_header;
18409             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
18410             out_ext->pNext = NULL;
18411             out_ext->presentWait = in_ext->presentWait;
18412             out_header->pNext = (void *)out_ext;
18413             out_header = (void *)out_ext;
18414             break;
18415         }
18416         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
18417         {
18418             VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18419             const VkPhysicalDevice16BitStorageFeatures32 *in_ext = (const VkPhysicalDevice16BitStorageFeatures32 *)in_header;
18420             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
18421             out_ext->pNext = NULL;
18422             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
18423             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
18424             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
18425             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
18426             out_header->pNext = (void *)out_ext;
18427             out_header = (void *)out_ext;
18428             break;
18429         }
18430         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
18431         {
18432             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18433             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *)in_header;
18434             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
18435             out_ext->pNext = NULL;
18436             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
18437             out_header->pNext = (void *)out_ext;
18438             out_header = (void *)out_ext;
18439             break;
18440         }
18441         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
18442         {
18443             VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18444             const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *)in_header;
18445             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
18446             out_ext->pNext = NULL;
18447             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
18448             out_header->pNext = (void *)out_ext;
18449             out_header = (void *)out_ext;
18450             break;
18451         }
18452         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
18453         {
18454             VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18455             const VkPhysicalDeviceProtectedMemoryFeatures32 *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures32 *)in_header;
18456             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
18457             out_ext->pNext = NULL;
18458             out_ext->protectedMemory = in_ext->protectedMemory;
18459             out_header->pNext = (void *)out_ext;
18460             out_header = (void *)out_ext;
18461             break;
18462         }
18463         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
18464         {
18465             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18466             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *)in_header;
18467             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
18468             out_ext->pNext = NULL;
18469             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
18470             out_header->pNext = (void *)out_ext;
18471             out_header = (void *)out_ext;
18472             break;
18473         }
18474         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
18475         {
18476             VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18477             const VkPhysicalDeviceMultiDrawFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT32 *)in_header;
18478             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
18479             out_ext->pNext = NULL;
18480             out_ext->multiDraw = in_ext->multiDraw;
18481             out_header->pNext = (void *)out_ext;
18482             out_header = (void *)out_ext;
18483             break;
18484         }
18485         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
18486         {
18487             VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18488             const VkPhysicalDeviceInlineUniformBlockFeatures32 *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures32 *)in_header;
18489             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
18490             out_ext->pNext = NULL;
18491             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
18492             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
18493             out_header->pNext = (void *)out_ext;
18494             out_header = (void *)out_ext;
18495             break;
18496         }
18497         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
18498         {
18499             VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18500             const VkPhysicalDeviceMaintenance4Features32 *in_ext = (const VkPhysicalDeviceMaintenance4Features32 *)in_header;
18501             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
18502             out_ext->pNext = NULL;
18503             out_ext->maintenance4 = in_ext->maintenance4;
18504             out_header->pNext = (void *)out_ext;
18505             out_header = (void *)out_ext;
18506             break;
18507         }
18508         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
18509         {
18510             VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18511             const VkPhysicalDeviceShaderDrawParametersFeatures32 *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures32 *)in_header;
18512             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
18513             out_ext->pNext = NULL;
18514             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
18515             out_header->pNext = (void *)out_ext;
18516             out_header = (void *)out_ext;
18517             break;
18518         }
18519         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
18520         {
18521             VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18522             const VkPhysicalDeviceShaderFloat16Int8Features32 *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features32 *)in_header;
18523             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
18524             out_ext->pNext = NULL;
18525             out_ext->shaderFloat16 = in_ext->shaderFloat16;
18526             out_ext->shaderInt8 = in_ext->shaderInt8;
18527             out_header->pNext = (void *)out_ext;
18528             out_header = (void *)out_ext;
18529             break;
18530         }
18531         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
18532         {
18533             VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18534             const VkPhysicalDeviceHostQueryResetFeatures32 *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures32 *)in_header;
18535             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
18536             out_ext->pNext = NULL;
18537             out_ext->hostQueryReset = in_ext->hostQueryReset;
18538             out_header->pNext = (void *)out_ext;
18539             out_header = (void *)out_ext;
18540             break;
18541         }
18542         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
18543         {
18544             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18545             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *)in_header;
18546             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
18547             out_ext->pNext = NULL;
18548             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
18549             out_header->pNext = (void *)out_ext;
18550             out_header = (void *)out_ext;
18551             break;
18552         }
18553         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
18554         {
18555             VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18556             const VkPhysicalDeviceDescriptorIndexingFeatures32 *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures32 *)in_header;
18557             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
18558             out_ext->pNext = NULL;
18559             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
18560             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
18561             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
18562             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
18563             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
18564             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
18565             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
18566             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
18567             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
18568             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
18569             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
18570             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
18571             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
18572             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
18573             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
18574             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
18575             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
18576             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
18577             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
18578             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
18579             out_header->pNext = (void *)out_ext;
18580             out_header = (void *)out_ext;
18581             break;
18582         }
18583         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
18584         {
18585             VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18586             const VkPhysicalDeviceTimelineSemaphoreFeatures32 *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures32 *)in_header;
18587             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
18588             out_ext->pNext = NULL;
18589             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
18590             out_header->pNext = (void *)out_ext;
18591             out_header = (void *)out_ext;
18592             break;
18593         }
18594         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
18595         {
18596             VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18597             const VkPhysicalDevice8BitStorageFeatures32 *in_ext = (const VkPhysicalDevice8BitStorageFeatures32 *)in_header;
18598             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
18599             out_ext->pNext = NULL;
18600             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
18601             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
18602             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
18603             out_header->pNext = (void *)out_ext;
18604             out_header = (void *)out_ext;
18605             break;
18606         }
18607         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
18608         {
18609             VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18610             const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *)in_header;
18611             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
18612             out_ext->pNext = NULL;
18613             out_ext->conditionalRendering = in_ext->conditionalRendering;
18614             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
18615             out_header->pNext = (void *)out_ext;
18616             out_header = (void *)out_ext;
18617             break;
18618         }
18619         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
18620         {
18621             VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18622             const VkPhysicalDeviceVulkanMemoryModelFeatures32 *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures32 *)in_header;
18623             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
18624             out_ext->pNext = NULL;
18625             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
18626             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
18627             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
18628             out_header->pNext = (void *)out_ext;
18629             out_header = (void *)out_ext;
18630             break;
18631         }
18632         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
18633         {
18634             VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18635             const VkPhysicalDeviceShaderAtomicInt64Features32 *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features32 *)in_header;
18636             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
18637             out_ext->pNext = NULL;
18638             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
18639             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
18640             out_header->pNext = (void *)out_ext;
18641             out_header = (void *)out_ext;
18642             break;
18643         }
18644         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
18645         {
18646             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18647             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *)in_header;
18648             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
18649             out_ext->pNext = NULL;
18650             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
18651             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
18652             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
18653             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
18654             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
18655             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
18656             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
18657             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
18658             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
18659             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
18660             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
18661             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
18662             out_header->pNext = (void *)out_ext;
18663             out_header = (void *)out_ext;
18664             break;
18665         }
18666         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
18667         {
18668             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18669             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *)in_header;
18670             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
18671             out_ext->pNext = NULL;
18672             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
18673             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
18674             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
18675             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
18676             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
18677             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
18678             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
18679             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
18680             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
18681             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
18682             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
18683             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
18684             out_header->pNext = (void *)out_ext;
18685             out_header = (void *)out_ext;
18686             break;
18687         }
18688         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
18689         {
18690             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18691             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *)in_header;
18692             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
18693             out_ext->pNext = NULL;
18694             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
18695             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
18696             out_header->pNext = (void *)out_ext;
18697             out_header = (void *)out_ext;
18698             break;
18699         }
18700         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
18701         {
18702             VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18703             const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *)in_header;
18704             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
18705             out_ext->pNext = NULL;
18706             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
18707             out_header->pNext = (void *)out_ext;
18708             out_header = (void *)out_ext;
18709             break;
18710         }
18711         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
18712         {
18713             VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18714             const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *)in_header;
18715             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
18716             out_ext->pNext = NULL;
18717             out_ext->transformFeedback = in_ext->transformFeedback;
18718             out_ext->geometryStreams = in_ext->geometryStreams;
18719             out_header->pNext = (void *)out_ext;
18720             out_header = (void *)out_ext;
18721             break;
18722         }
18723         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
18724         {
18725             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18726             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *)in_header;
18727             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
18728             out_ext->pNext = NULL;
18729             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
18730             out_header->pNext = (void *)out_ext;
18731             out_header = (void *)out_ext;
18732             break;
18733         }
18734         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
18735         {
18736             VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18737             const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *)in_header;
18738             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
18739             out_ext->pNext = NULL;
18740             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
18741             out_header->pNext = (void *)out_ext;
18742             out_header = (void *)out_ext;
18743             break;
18744         }
18745         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
18746         {
18747             VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18748             const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *)in_header;
18749             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
18750             out_ext->pNext = NULL;
18751             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
18752             out_header->pNext = (void *)out_ext;
18753             out_header = (void *)out_ext;
18754             break;
18755         }
18756         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
18757         {
18758             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18759             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *)in_header;
18760             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
18761             out_ext->pNext = NULL;
18762             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
18763             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
18764             out_header->pNext = (void *)out_ext;
18765             out_header = (void *)out_ext;
18766             break;
18767         }
18768         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
18769         {
18770             VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18771             const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *)in_header;
18772             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
18773             out_ext->pNext = NULL;
18774             out_ext->imageFootprint = in_ext->imageFootprint;
18775             out_header->pNext = (void *)out_ext;
18776             out_header = (void *)out_ext;
18777             break;
18778         }
18779         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
18780         {
18781             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18782             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *)in_header;
18783             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
18784             out_ext->pNext = NULL;
18785             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
18786             out_header->pNext = (void *)out_ext;
18787             out_header = (void *)out_ext;
18788             break;
18789         }
18790         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
18791         {
18792             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18793             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *)in_header;
18794             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
18795             out_ext->pNext = NULL;
18796             out_ext->indirectCopy = in_ext->indirectCopy;
18797             out_header->pNext = (void *)out_ext;
18798             out_header = (void *)out_ext;
18799             break;
18800         }
18801         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
18802         {
18803             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18804             const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *)in_header;
18805             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
18806             out_ext->pNext = NULL;
18807             out_ext->memoryDecompression = in_ext->memoryDecompression;
18808             out_header->pNext = (void *)out_ext;
18809             out_header = (void *)out_ext;
18810             break;
18811         }
18812         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
18813         {
18814             VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18815             const VkPhysicalDeviceShadingRateImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV32 *)in_header;
18816             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
18817             out_ext->pNext = NULL;
18818             out_ext->shadingRateImage = in_ext->shadingRateImage;
18819             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
18820             out_header->pNext = (void *)out_ext;
18821             out_header = (void *)out_ext;
18822             break;
18823         }
18824         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
18825         {
18826             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18827             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *)in_header;
18828             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
18829             out_ext->pNext = NULL;
18830             out_ext->invocationMask = in_ext->invocationMask;
18831             out_header->pNext = (void *)out_ext;
18832             out_header = (void *)out_ext;
18833             break;
18834         }
18835         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
18836         {
18837             VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18838             const VkPhysicalDeviceMeshShaderFeaturesNV32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV32 *)in_header;
18839             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
18840             out_ext->pNext = NULL;
18841             out_ext->taskShader = in_ext->taskShader;
18842             out_ext->meshShader = in_ext->meshShader;
18843             out_header->pNext = (void *)out_ext;
18844             out_header = (void *)out_ext;
18845             break;
18846         }
18847         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
18848         {
18849             VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18850             const VkPhysicalDeviceMeshShaderFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT32 *)in_header;
18851             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
18852             out_ext->pNext = NULL;
18853             out_ext->taskShader = in_ext->taskShader;
18854             out_ext->meshShader = in_ext->meshShader;
18855             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
18856             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
18857             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
18858             out_header->pNext = (void *)out_ext;
18859             out_header = (void *)out_ext;
18860             break;
18861         }
18862         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
18863         {
18864             VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18865             const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *)in_header;
18866             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
18867             out_ext->pNext = NULL;
18868             out_ext->accelerationStructure = in_ext->accelerationStructure;
18869             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
18870             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
18871             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
18872             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
18873             out_header->pNext = (void *)out_ext;
18874             out_header = (void *)out_ext;
18875             break;
18876         }
18877         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
18878         {
18879             VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18880             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *)in_header;
18881             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
18882             out_ext->pNext = NULL;
18883             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
18884             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
18885             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
18886             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
18887             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
18888             out_header->pNext = (void *)out_ext;
18889             out_header = (void *)out_ext;
18890             break;
18891         }
18892         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
18893         {
18894             VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18895             const VkPhysicalDeviceRayQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR32 *)in_header;
18896             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
18897             out_ext->pNext = NULL;
18898             out_ext->rayQuery = in_ext->rayQuery;
18899             out_header->pNext = (void *)out_ext;
18900             out_header = (void *)out_ext;
18901             break;
18902         }
18903         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
18904         {
18905             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18906             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *)in_header;
18907             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
18908             out_ext->pNext = NULL;
18909             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
18910             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
18911             out_header->pNext = (void *)out_ext;
18912             out_header = (void *)out_ext;
18913             break;
18914         }
18915         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
18916         {
18917             VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18918             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *)in_header;
18919             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
18920             out_ext->pNext = NULL;
18921             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
18922             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
18923             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
18924             out_header->pNext = (void *)out_ext;
18925             out_header = (void *)out_ext;
18926             break;
18927         }
18928         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
18929         {
18930             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18931             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *)in_header;
18932             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
18933             out_ext->pNext = NULL;
18934             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
18935             out_header->pNext = (void *)out_ext;
18936             out_header = (void *)out_ext;
18937             break;
18938         }
18939         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
18940         {
18941             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18942             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *)in_header;
18943             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
18944             out_ext->pNext = NULL;
18945             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
18946             out_header->pNext = (void *)out_ext;
18947             out_header = (void *)out_ext;
18948             break;
18949         }
18950         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
18951         {
18952             VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18953             const VkPhysicalDeviceScalarBlockLayoutFeatures32 *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures32 *)in_header;
18954             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
18955             out_ext->pNext = NULL;
18956             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
18957             out_header->pNext = (void *)out_ext;
18958             out_header = (void *)out_ext;
18959             break;
18960         }
18961         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
18962         {
18963             VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18964             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *)in_header;
18965             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
18966             out_ext->pNext = NULL;
18967             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
18968             out_header->pNext = (void *)out_ext;
18969             out_header = (void *)out_ext;
18970             break;
18971         }
18972         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
18973         {
18974             VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18975             const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *)in_header;
18976             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
18977             out_ext->pNext = NULL;
18978             out_ext->depthClipEnable = in_ext->depthClipEnable;
18979             out_header->pNext = (void *)out_ext;
18980             out_header = (void *)out_ext;
18981             break;
18982         }
18983         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
18984         {
18985             VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18986             const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *)in_header;
18987             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
18988             out_ext->pNext = NULL;
18989             out_ext->memoryPriority = in_ext->memoryPriority;
18990             out_header->pNext = (void *)out_ext;
18991             out_header = (void *)out_ext;
18992             break;
18993         }
18994         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
18995         {
18996             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18997             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *)in_header;
18998             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
18999             out_ext->pNext = NULL;
19000             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
19001             out_header->pNext = (void *)out_ext;
19002             out_header = (void *)out_ext;
19003             break;
19004         }
19005         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
19006         {
19007             VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19008             const VkPhysicalDeviceBufferDeviceAddressFeatures32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures32 *)in_header;
19009             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
19010             out_ext->pNext = NULL;
19011             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
19012             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
19013             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
19014             out_header->pNext = (void *)out_ext;
19015             out_header = (void *)out_ext;
19016             break;
19017         }
19018         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
19019         {
19020             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19021             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *)in_header;
19022             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
19023             out_ext->pNext = NULL;
19024             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
19025             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
19026             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
19027             out_header->pNext = (void *)out_ext;
19028             out_header = (void *)out_ext;
19029             break;
19030         }
19031         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
19032         {
19033             VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19034             const VkPhysicalDeviceImagelessFramebufferFeatures32 *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures32 *)in_header;
19035             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
19036             out_ext->pNext = NULL;
19037             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
19038             out_header->pNext = (void *)out_ext;
19039             out_header = (void *)out_ext;
19040             break;
19041         }
19042         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
19043         {
19044             VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19045             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *)in_header;
19046             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
19047             out_ext->pNext = NULL;
19048             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
19049             out_header->pNext = (void *)out_ext;
19050             out_header = (void *)out_ext;
19051             break;
19052         }
19053         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
19054         {
19055             VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19056             const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *)in_header;
19057             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
19058             out_ext->pNext = NULL;
19059             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
19060             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
19061             out_header->pNext = (void *)out_ext;
19062             out_header = (void *)out_ext;
19063             break;
19064         }
19065         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
19066         {
19067             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19068             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *)in_header;
19069             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
19070             out_ext->pNext = NULL;
19071             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
19072             out_header->pNext = (void *)out_ext;
19073             out_header = (void *)out_ext;
19074             break;
19075         }
19076         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
19077         {
19078             VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19079             const VkPhysicalDevicePresentBarrierFeaturesNV32 *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV32 *)in_header;
19080             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
19081             out_ext->pNext = NULL;
19082             out_ext->presentBarrier = in_ext->presentBarrier;
19083             out_header->pNext = (void *)out_ext;
19084             out_header = (void *)out_ext;
19085             break;
19086         }
19087         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
19088         {
19089             VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19090             const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *)in_header;
19091             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
19092             out_ext->pNext = NULL;
19093             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
19094             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
19095             out_header->pNext = (void *)out_ext;
19096             out_header = (void *)out_ext;
19097             break;
19098         }
19099         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
19100         {
19101             VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19102             const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *)in_header;
19103             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
19104             out_ext->pNext = NULL;
19105             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
19106             out_header->pNext = (void *)out_ext;
19107             out_header = (void *)out_ext;
19108             break;
19109         }
19110         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
19111         {
19112             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19113             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *)in_header;
19114             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
19115             out_ext->pNext = NULL;
19116             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
19117             out_header->pNext = (void *)out_ext;
19118             out_header = (void *)out_ext;
19119             break;
19120         }
19121         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
19122         {
19123             VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19124             const VkPhysicalDeviceShaderClockFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR32 *)in_header;
19125             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
19126             out_ext->pNext = NULL;
19127             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
19128             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
19129             out_header->pNext = (void *)out_ext;
19130             out_header = (void *)out_ext;
19131             break;
19132         }
19133         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
19134         {
19135             VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19136             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *)in_header;
19137             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
19138             out_ext->pNext = NULL;
19139             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
19140             out_header->pNext = (void *)out_ext;
19141             out_header = (void *)out_ext;
19142             break;
19143         }
19144         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
19145         {
19146             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19147             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *)in_header;
19148             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
19149             out_ext->pNext = NULL;
19150             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
19151             out_header->pNext = (void *)out_ext;
19152             out_header = (void *)out_ext;
19153             break;
19154         }
19155         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
19156         {
19157             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19158             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *)in_header;
19159             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
19160             out_ext->pNext = NULL;
19161             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
19162             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
19163             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
19164             out_header->pNext = (void *)out_ext;
19165             out_header = (void *)out_ext;
19166             break;
19167         }
19168         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
19169         {
19170             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19171             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *)in_header;
19172             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
19173             out_ext->pNext = NULL;
19174             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
19175             out_header->pNext = (void *)out_ext;
19176             out_header = (void *)out_ext;
19177             break;
19178         }
19179         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
19180         {
19181             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19182             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *)in_header;
19183             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
19184             out_ext->pNext = NULL;
19185             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
19186             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
19187             out_header->pNext = (void *)out_ext;
19188             out_header = (void *)out_ext;
19189             break;
19190         }
19191         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
19192         {
19193             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19194             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *)in_header;
19195             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
19196             out_ext->pNext = NULL;
19197             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
19198             out_header->pNext = (void *)out_ext;
19199             out_header = (void *)out_ext;
19200             break;
19201         }
19202         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
19203         {
19204             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19205             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *)in_header;
19206             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
19207             out_ext->pNext = NULL;
19208             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
19209             out_header->pNext = (void *)out_ext;
19210             out_header = (void *)out_ext;
19211             break;
19212         }
19213         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
19214         {
19215             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19216             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *)in_header;
19217             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
19218             out_ext->pNext = NULL;
19219             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
19220             out_header->pNext = (void *)out_ext;
19221             out_header = (void *)out_ext;
19222             break;
19223         }
19224         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
19225         {
19226             VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19227             const VkPhysicalDeviceSubgroupSizeControlFeatures32 *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures32 *)in_header;
19228             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
19229             out_ext->pNext = NULL;
19230             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
19231             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
19232             out_header->pNext = (void *)out_ext;
19233             out_header = (void *)out_ext;
19234             break;
19235         }
19236         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
19237         {
19238             VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19239             const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *)in_header;
19240             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
19241             out_ext->pNext = NULL;
19242             out_ext->rectangularLines = in_ext->rectangularLines;
19243             out_ext->bresenhamLines = in_ext->bresenhamLines;
19244             out_ext->smoothLines = in_ext->smoothLines;
19245             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
19246             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
19247             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
19248             out_header->pNext = (void *)out_ext;
19249             out_header = (void *)out_ext;
19250             break;
19251         }
19252         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
19253         {
19254             VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19255             const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *)in_header;
19256             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
19257             out_ext->pNext = NULL;
19258             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
19259             out_header->pNext = (void *)out_ext;
19260             out_header = (void *)out_ext;
19261             break;
19262         }
19263         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
19264         {
19265             VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19266             const VkPhysicalDeviceVulkan11Features32 *in_ext = (const VkPhysicalDeviceVulkan11Features32 *)in_header;
19267             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
19268             out_ext->pNext = NULL;
19269             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
19270             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
19271             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
19272             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
19273             out_ext->multiview = in_ext->multiview;
19274             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
19275             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
19276             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
19277             out_ext->variablePointers = in_ext->variablePointers;
19278             out_ext->protectedMemory = in_ext->protectedMemory;
19279             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
19280             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
19281             out_header->pNext = (void *)out_ext;
19282             out_header = (void *)out_ext;
19283             break;
19284         }
19285         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
19286         {
19287             VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19288             const VkPhysicalDeviceVulkan12Features32 *in_ext = (const VkPhysicalDeviceVulkan12Features32 *)in_header;
19289             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
19290             out_ext->pNext = NULL;
19291             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
19292             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
19293             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
19294             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
19295             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
19296             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
19297             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
19298             out_ext->shaderFloat16 = in_ext->shaderFloat16;
19299             out_ext->shaderInt8 = in_ext->shaderInt8;
19300             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
19301             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
19302             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
19303             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
19304             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
19305             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
19306             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
19307             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
19308             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
19309             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
19310             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
19311             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
19312             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
19313             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
19314             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
19315             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
19316             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
19317             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
19318             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
19319             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
19320             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
19321             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
19322             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
19323             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
19324             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
19325             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
19326             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
19327             out_ext->hostQueryReset = in_ext->hostQueryReset;
19328             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
19329             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
19330             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
19331             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
19332             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
19333             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
19334             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
19335             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
19336             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
19337             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
19338             out_header->pNext = (void *)out_ext;
19339             out_header = (void *)out_ext;
19340             break;
19341         }
19342         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
19343         {
19344             VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19345             const VkPhysicalDeviceVulkan13Features32 *in_ext = (const VkPhysicalDeviceVulkan13Features32 *)in_header;
19346             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
19347             out_ext->pNext = NULL;
19348             out_ext->robustImageAccess = in_ext->robustImageAccess;
19349             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
19350             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
19351             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
19352             out_ext->privateData = in_ext->privateData;
19353             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
19354             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
19355             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
19356             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
19357             out_ext->synchronization2 = in_ext->synchronization2;
19358             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
19359             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
19360             out_ext->dynamicRendering = in_ext->dynamicRendering;
19361             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
19362             out_ext->maintenance4 = in_ext->maintenance4;
19363             out_header->pNext = (void *)out_ext;
19364             out_header = (void *)out_ext;
19365             break;
19366         }
19367         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
19368         {
19369             VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19370             const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *)in_header;
19371             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
19372             out_ext->pNext = NULL;
19373             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
19374             out_header->pNext = (void *)out_ext;
19375             out_header = (void *)out_ext;
19376             break;
19377         }
19378         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
19379         {
19380             VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19381             const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *)in_header;
19382             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
19383             out_ext->pNext = NULL;
19384             out_ext->customBorderColors = in_ext->customBorderColors;
19385             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
19386             out_header->pNext = (void *)out_ext;
19387             out_header = (void *)out_ext;
19388             break;
19389         }
19390         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
19391         {
19392             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19393             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *)in_header;
19394             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
19395             out_ext->pNext = NULL;
19396             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
19397             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
19398             out_header->pNext = (void *)out_ext;
19399             out_header = (void *)out_ext;
19400             break;
19401         }
19402         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
19403         {
19404             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19405             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *)in_header;
19406             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
19407             out_ext->pNext = NULL;
19408             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
19409             out_header->pNext = (void *)out_ext;
19410             out_header = (void *)out_ext;
19411             break;
19412         }
19413         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
19414         {
19415             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19416             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *)in_header;
19417             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
19418             out_ext->pNext = NULL;
19419             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
19420             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
19421             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
19422             out_header->pNext = (void *)out_ext;
19423             out_header = (void *)out_ext;
19424             break;
19425         }
19426         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
19427         {
19428             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19429             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *)in_header;
19430             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
19431             out_ext->pNext = NULL;
19432             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
19433             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
19434             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
19435             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
19436             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
19437             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
19438             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
19439             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
19440             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
19441             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
19442             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
19443             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
19444             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
19445             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
19446             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
19447             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
19448             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
19449             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
19450             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
19451             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
19452             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
19453             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
19454             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
19455             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
19456             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
19457             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
19458             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
19459             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
19460             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
19461             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
19462             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
19463             out_header->pNext = (void *)out_ext;
19464             out_header = (void *)out_ext;
19465             break;
19466         }
19467         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
19468         {
19469             VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19470             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *)in_header;
19471             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
19472             out_ext->pNext = NULL;
19473             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
19474             out_header->pNext = (void *)out_ext;
19475             out_header = (void *)out_ext;
19476             break;
19477         }
19478         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
19479         {
19480             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19481             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *)in_header;
19482             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
19483             out_ext->pNext = NULL;
19484             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
19485             out_header->pNext = (void *)out_ext;
19486             out_header = (void *)out_ext;
19487             break;
19488         }
19489         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
19490         {
19491             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19492             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *)in_header;
19493             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
19494             out_ext->pNext = NULL;
19495             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
19496             out_header->pNext = (void *)out_ext;
19497             out_header = (void *)out_ext;
19498             break;
19499         }
19500         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
19501         {
19502             VkPhysicalDeviceRobustness2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19503             const VkPhysicalDeviceRobustness2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT32 *)in_header;
19504             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
19505             out_ext->pNext = NULL;
19506             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
19507             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
19508             out_ext->nullDescriptor = in_ext->nullDescriptor;
19509             out_header->pNext = (void *)out_ext;
19510             out_header = (void *)out_ext;
19511             break;
19512         }
19513         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
19514         {
19515             VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19516             const VkPhysicalDeviceImageRobustnessFeatures32 *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures32 *)in_header;
19517             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
19518             out_ext->pNext = NULL;
19519             out_ext->robustImageAccess = in_ext->robustImageAccess;
19520             out_header->pNext = (void *)out_ext;
19521             out_header = (void *)out_ext;
19522             break;
19523         }
19524         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
19525         {
19526             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19527             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *)in_header;
19528             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
19529             out_ext->pNext = NULL;
19530             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
19531             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
19532             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
19533             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
19534             out_header->pNext = (void *)out_ext;
19535             out_header = (void *)out_ext;
19536             break;
19537         }
19538         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
19539         {
19540             VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19541             const VkPhysicalDevice4444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT32 *)in_header;
19542             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
19543             out_ext->pNext = NULL;
19544             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
19545             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
19546             out_header->pNext = (void *)out_ext;
19547             out_header = (void *)out_ext;
19548             break;
19549         }
19550         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
19551         {
19552             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19553             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *)in_header;
19554             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
19555             out_ext->pNext = NULL;
19556             out_ext->subpassShading = in_ext->subpassShading;
19557             out_header->pNext = (void *)out_ext;
19558             out_header = (void *)out_ext;
19559             break;
19560         }
19561         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
19562         {
19563             VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19564             const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *)in_header;
19565             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
19566             out_ext->pNext = NULL;
19567             out_ext->clustercullingShader = in_ext->clustercullingShader;
19568             out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
19569             out_header->pNext = (void *)out_ext;
19570             out_header = (void *)out_ext;
19571             break;
19572         }
19573         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
19574         {
19575             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19576             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *)in_header;
19577             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
19578             out_ext->pNext = NULL;
19579             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
19580             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
19581             out_header->pNext = (void *)out_ext;
19582             out_header = (void *)out_ext;
19583             break;
19584         }
19585         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
19586         {
19587             VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19588             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *)in_header;
19589             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
19590             out_ext->pNext = NULL;
19591             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
19592             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
19593             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
19594             out_header->pNext = (void *)out_ext;
19595             out_header = (void *)out_ext;
19596             break;
19597         }
19598         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
19599         {
19600             VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19601             const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *)in_header;
19602             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
19603             out_ext->pNext = NULL;
19604             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
19605             out_header->pNext = (void *)out_ext;
19606             out_header = (void *)out_ext;
19607             break;
19608         }
19609         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
19610         {
19611             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19612             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *)in_header;
19613             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
19614             out_ext->pNext = NULL;
19615             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
19616             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
19617             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
19618             out_header->pNext = (void *)out_ext;
19619             out_header = (void *)out_ext;
19620             break;
19621         }
19622         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
19623         {
19624             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19625             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *)in_header;
19626             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
19627             out_ext->pNext = NULL;
19628             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
19629             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
19630             out_header->pNext = (void *)out_ext;
19631             out_header = (void *)out_ext;
19632             break;
19633         }
19634         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
19635         {
19636             VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19637             const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *)in_header;
19638             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
19639             out_ext->pNext = NULL;
19640             out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
19641             out_header->pNext = (void *)out_ext;
19642             out_header = (void *)out_ext;
19643             break;
19644         }
19645         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
19646         {
19647             VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19648             const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *)in_header;
19649             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
19650             out_ext->pNext = NULL;
19651             out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
19652             out_header->pNext = (void *)out_ext;
19653             out_header = (void *)out_ext;
19654             break;
19655         }
19656         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
19657         {
19658             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19659             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *)in_header;
19660             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
19661             out_ext->pNext = NULL;
19662             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
19663             out_header->pNext = (void *)out_ext;
19664             out_header = (void *)out_ext;
19665             break;
19666         }
19667         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
19668         {
19669             VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19670             const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *)in_header;
19671             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
19672             out_ext->pNext = NULL;
19673             out_ext->depthClipControl = in_ext->depthClipControl;
19674             out_header->pNext = (void *)out_ext;
19675             out_header = (void *)out_ext;
19676             break;
19677         }
19678         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
19679         {
19680             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19681             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *)in_header;
19682             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
19683             out_ext->pNext = NULL;
19684             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
19685             out_header->pNext = (void *)out_ext;
19686             out_header = (void *)out_ext;
19687             break;
19688         }
19689         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
19690         {
19691             VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19692             const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *)in_header;
19693             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
19694             out_ext->pNext = NULL;
19695             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
19696             out_header->pNext = (void *)out_ext;
19697             out_header = (void *)out_ext;
19698             break;
19699         }
19700         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
19701         {
19702             VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19703             const VkPhysicalDeviceSynchronization2Features32 *in_ext = (const VkPhysicalDeviceSynchronization2Features32 *)in_header;
19704             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
19705             out_ext->pNext = NULL;
19706             out_ext->synchronization2 = in_ext->synchronization2;
19707             out_header->pNext = (void *)out_ext;
19708             out_header = (void *)out_ext;
19709             break;
19710         }
19711         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
19712         {
19713             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19714             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *)in_header;
19715             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
19716             out_ext->pNext = NULL;
19717             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
19718             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
19719             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
19720             out_header->pNext = (void *)out_ext;
19721             out_header = (void *)out_ext;
19722             break;
19723         }
19724         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
19725         {
19726             VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19727             const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *)in_header;
19728             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
19729             out_ext->pNext = NULL;
19730             out_ext->legacyDithering = in_ext->legacyDithering;
19731             out_header->pNext = (void *)out_ext;
19732             out_header = (void *)out_ext;
19733             break;
19734         }
19735         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
19736         {
19737             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19738             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *)in_header;
19739             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
19740             out_ext->pNext = NULL;
19741             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
19742             out_header->pNext = (void *)out_ext;
19743             out_header = (void *)out_ext;
19744             break;
19745         }
19746         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
19747         {
19748             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19749             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *)in_header;
19750             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
19751             out_ext->pNext = NULL;
19752             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
19753             out_header->pNext = (void *)out_ext;
19754             out_header = (void *)out_ext;
19755             break;
19756         }
19757         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
19758         {
19759             VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19760             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *)in_header;
19761             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
19762             out_ext->pNext = NULL;
19763             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
19764             out_header->pNext = (void *)out_ext;
19765             out_header = (void *)out_ext;
19766             break;
19767         }
19768         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
19769         {
19770             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19771             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *)in_header;
19772             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
19773             out_ext->pNext = NULL;
19774             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
19775             out_header->pNext = (void *)out_ext;
19776             out_header = (void *)out_ext;
19777             break;
19778         }
19779         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
19780         {
19781             VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19782             const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *)in_header;
19783             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
19784             out_ext->pNext = NULL;
19785             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
19786             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
19787             out_header->pNext = (void *)out_ext;
19788             out_header = (void *)out_ext;
19789             break;
19790         }
19791         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
19792         {
19793             VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19794             const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *)in_header;
19795             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
19796             out_ext->pNext = NULL;
19797             out_ext->descriptorBuffer = in_ext->descriptorBuffer;
19798             out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
19799             out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
19800             out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
19801             out_header->pNext = (void *)out_ext;
19802             out_header = (void *)out_ext;
19803             break;
19804         }
19805         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
19806         {
19807             VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19808             const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *)in_header;
19809             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
19810             out_ext->pNext = NULL;
19811             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
19812             out_header->pNext = (void *)out_ext;
19813             out_header = (void *)out_ext;
19814             break;
19815         }
19816         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
19817         {
19818             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19819             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *)in_header;
19820             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
19821             out_ext->pNext = NULL;
19822             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
19823             out_header->pNext = (void *)out_ext;
19824             out_header = (void *)out_ext;
19825             break;
19826         }
19827         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
19828         {
19829             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19830             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *)in_header;
19831             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
19832             out_ext->pNext = NULL;
19833             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
19834             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
19835             out_header->pNext = (void *)out_ext;
19836             out_header = (void *)out_ext;
19837             break;
19838         }
19839         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
19840         {
19841             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19842             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *)in_header;
19843             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
19844             out_ext->pNext = NULL;
19845             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
19846             out_header->pNext = (void *)out_ext;
19847             out_header = (void *)out_ext;
19848             break;
19849         }
19850         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
19851         {
19852             VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19853             const VkPhysicalDeviceDynamicRenderingFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures32 *)in_header;
19854             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
19855             out_ext->pNext = NULL;
19856             out_ext->dynamicRendering = in_ext->dynamicRendering;
19857             out_header->pNext = (void *)out_ext;
19858             out_header = (void *)out_ext;
19859             break;
19860         }
19861         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
19862         {
19863             VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19864             const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *)in_header;
19865             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
19866             out_ext->pNext = NULL;
19867             out_ext->minLod = in_ext->minLod;
19868             out_header->pNext = (void *)out_ext;
19869             out_header = (void *)out_ext;
19870             break;
19871         }
19872         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
19873         {
19874             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19875             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *)in_header;
19876             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
19877             out_ext->pNext = NULL;
19878             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
19879             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
19880             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
19881             out_header->pNext = (void *)out_ext;
19882             out_header = (void *)out_ext;
19883             break;
19884         }
19885         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
19886         {
19887             VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19888             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *)in_header;
19889             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
19890             out_ext->pNext = NULL;
19891             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
19892             out_header->pNext = (void *)out_ext;
19893             out_header = (void *)out_ext;
19894             break;
19895         }
19896         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
19897         {
19898             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19899             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *)in_header;
19900             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
19901             out_ext->pNext = NULL;
19902             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
19903             out_header->pNext = (void *)out_ext;
19904             out_header = (void *)out_ext;
19905             break;
19906         }
19907         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
19908         {
19909             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19910             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *)in_header;
19911             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
19912             out_ext->pNext = NULL;
19913             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
19914             out_header->pNext = (void *)out_ext;
19915             out_header = (void *)out_ext;
19916             break;
19917         }
19918         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
19919         {
19920             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19921             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *)in_header;
19922             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
19923             out_ext->pNext = NULL;
19924             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
19925             out_header->pNext = (void *)out_ext;
19926             out_header = (void *)out_ext;
19927             break;
19928         }
19929         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
19930         {
19931             VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19932             const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *)in_header;
19933             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
19934             out_ext->pNext = NULL;
19935             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
19936             out_header->pNext = (void *)out_ext;
19937             out_header = (void *)out_ext;
19938             break;
19939         }
19940         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
19941         {
19942             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19943             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *)in_header;
19944             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
19945             out_ext->pNext = NULL;
19946             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
19947             out_header->pNext = (void *)out_ext;
19948             out_header = (void *)out_ext;
19949             break;
19950         }
19951         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
19952         {
19953             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19954             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *)in_header;
19955             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
19956             out_ext->pNext = NULL;
19957             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
19958             out_header->pNext = (void *)out_ext;
19959             out_header = (void *)out_ext;
19960             break;
19961         }
19962         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
19963         {
19964             VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19965             const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *)in_header;
19966             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
19967             out_ext->pNext = NULL;
19968             out_ext->micromap = in_ext->micromap;
19969             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
19970             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
19971             out_header->pNext = (void *)out_ext;
19972             out_header = (void *)out_ext;
19973             break;
19974         }
19975         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
19976         {
19977             VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19978             const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *)in_header;
19979             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
19980             out_ext->pNext = NULL;
19981             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
19982             out_header->pNext = (void *)out_ext;
19983             out_header = (void *)out_ext;
19984             break;
19985         }
19986         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
19987         {
19988             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19989             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *)in_header;
19990             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
19991             out_ext->pNext = NULL;
19992             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
19993             out_header->pNext = (void *)out_ext;
19994             out_header = (void *)out_ext;
19995             break;
19996         }
19997         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
19998         {
19999             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20000             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *)in_header;
20001             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
20002             out_ext->pNext = NULL;
20003             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
20004             out_header->pNext = (void *)out_ext;
20005             out_header = (void *)out_ext;
20006             break;
20007         }
20008         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
20009         {
20010             VkPhysicalDevicePipelineRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20011             const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *)in_header;
20012             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
20013             out_ext->pNext = NULL;
20014             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
20015             out_header->pNext = (void *)out_ext;
20016             out_header = (void *)out_ext;
20017             break;
20018         }
20019         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
20020         {
20021             VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20022             const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *)in_header;
20023             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
20024             out_ext->pNext = NULL;
20025             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
20026             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
20027             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
20028             out_header->pNext = (void *)out_ext;
20029             out_header = (void *)out_ext;
20030             break;
20031         }
20032         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
20033         {
20034             VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20035             const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *)in_header;
20036             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
20037             out_ext->pNext = NULL;
20038             out_ext->tileProperties = in_ext->tileProperties;
20039             out_header->pNext = (void *)out_ext;
20040             out_header = (void *)out_ext;
20041             break;
20042         }
20043         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
20044         {
20045             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20046             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *)in_header;
20047             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
20048             out_ext->pNext = NULL;
20049             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
20050             out_header->pNext = (void *)out_ext;
20051             out_header = (void *)out_ext;
20052             break;
20053         }
20054         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
20055         {
20056             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20057             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *)in_header;
20058             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
20059             out_ext->pNext = NULL;
20060             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
20061             out_header->pNext = (void *)out_ext;
20062             out_header = (void *)out_ext;
20063             break;
20064         }
20065         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
20066         {
20067             VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20068             const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *)in_header;
20069             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
20070             out_ext->pNext = NULL;
20071             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
20072             out_header->pNext = (void *)out_ext;
20073             out_header = (void *)out_ext;
20074             break;
20075         }
20076         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
20077         {
20078             VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20079             const VkPhysicalDeviceOpticalFlowFeaturesNV32 *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV32 *)in_header;
20080             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
20081             out_ext->pNext = NULL;
20082             out_ext->opticalFlow = in_ext->opticalFlow;
20083             out_header->pNext = (void *)out_ext;
20084             out_header = (void *)out_ext;
20085             break;
20086         }
20087         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
20088         {
20089             VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20090             const VkPhysicalDeviceFaultFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT32 *)in_header;
20091             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
20092             out_ext->pNext = NULL;
20093             out_ext->deviceFault = in_ext->deviceFault;
20094             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
20095             out_header->pNext = (void *)out_ext;
20096             out_header = (void *)out_ext;
20097             break;
20098         }
20099         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
20100         {
20101             VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20102             const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *)in_header;
20103             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
20104             out_ext->pNext = NULL;
20105             out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
20106             out_header->pNext = (void *)out_ext;
20107             out_header = (void *)out_ext;
20108             break;
20109         }
20110         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
20111         {
20112             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20113             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *)in_header;
20114             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
20115             out_ext->pNext = NULL;
20116             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
20117             out_header->pNext = (void *)out_ext;
20118             out_header = (void *)out_ext;
20119             break;
20120         }
20121         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
20122         {
20123             VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20124             const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *)in_header;
20125             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT;
20126             out_ext->pNext = NULL;
20127             out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
20128             out_header->pNext = (void *)out_ext;
20129             out_header = (void *)out_ext;
20130             break;
20131         }
20132         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
20133         {
20134             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20135             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *)in_header;
20136             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
20137             out_ext->pNext = NULL;
20138             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
20139             out_header->pNext = (void *)out_ext;
20140             out_header = (void *)out_ext;
20141             break;
20142         }
20143         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
20144         {
20145             VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20146             const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *)in_header;
20147             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
20148             out_ext->pNext = NULL;
20149             out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
20150             out_header->pNext = (void *)out_ext;
20151             out_header = (void *)out_ext;
20152             break;
20153         }
20154         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
20155         {
20156             VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20157             const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *)in_header;
20158             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
20159             out_ext->pNext = NULL;
20160             out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
20161             out_header->pNext = (void *)out_ext;
20162             out_header = (void *)out_ext;
20163             break;
20164         }
20165         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
20166         {
20167             VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20168             const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *)in_header;
20169             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
20170             out_ext->pNext = NULL;
20171             out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
20172             out_header->pNext = (void *)out_ext;
20173             out_header = (void *)out_ext;
20174             break;
20175         }
20176         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
20177         {
20178             VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20179             const VkPhysicalDeviceShaderObjectFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT32 *)in_header;
20180             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
20181             out_ext->pNext = NULL;
20182             out_ext->shaderObject = in_ext->shaderObject;
20183             out_header->pNext = (void *)out_ext;
20184             out_header = (void *)out_ext;
20185             break;
20186         }
20187         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
20188         {
20189             VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20190             const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *)in_header;
20191             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
20192             out_ext->pNext = NULL;
20193             out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess;
20194             out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess;
20195             out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess;
20196             out_header->pNext = (void *)out_ext;
20197             out_header = (void *)out_ext;
20198             break;
20199         }
20200         default:
20201             FIXME("Unhandled sType %u.\n", in_header->sType);
20202             break;
20203         }
20204     }
20205 }
20206
20207 static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDeviceFeatures2 *in, VkPhysicalDeviceFeatures232 *out)
20208 {
20209     const VkBaseInStructure *in_header;
20210     VkBaseOutStructure32 *out_header = (void *)out;
20211
20212     if (!in) return;
20213
20214     out->features = in->features;
20215
20216     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
20217     {
20218         switch (in_header->sType)
20219         {
20220         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
20221         {
20222             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV);
20223             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header;
20224             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
20225             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
20226             out_header = (void *)out_ext;
20227             break;
20228         }
20229         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
20230         {
20231             VkPhysicalDevicePrivateDataFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES);
20232             const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header;
20233             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
20234             out_ext->privateData = in_ext->privateData;
20235             out_header = (void *)out_ext;
20236             break;
20237         }
20238         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
20239         {
20240             VkPhysicalDeviceVariablePointersFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
20241             const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header;
20242             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
20243             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
20244             out_ext->variablePointers = in_ext->variablePointers;
20245             out_header = (void *)out_ext;
20246             break;
20247         }
20248         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
20249         {
20250             VkPhysicalDeviceMultiviewFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
20251             const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header;
20252             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
20253             out_ext->multiview = in_ext->multiview;
20254             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
20255             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
20256             out_header = (void *)out_ext;
20257             break;
20258         }
20259         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
20260         {
20261             VkPhysicalDevicePresentIdFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR);
20262             const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header;
20263             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
20264             out_ext->presentId = in_ext->presentId;
20265             out_header = (void *)out_ext;
20266             break;
20267         }
20268         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
20269         {
20270             VkPhysicalDevicePresentWaitFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR);
20271             const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header;
20272             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
20273             out_ext->presentWait = in_ext->presentWait;
20274             out_header = (void *)out_ext;
20275             break;
20276         }
20277         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
20278         {
20279             VkPhysicalDevice16BitStorageFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
20280             const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header;
20281             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
20282             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
20283             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
20284             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
20285             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
20286             out_header = (void *)out_ext;
20287             break;
20288         }
20289         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
20290         {
20291             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
20292             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header;
20293             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
20294             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
20295             out_header = (void *)out_ext;
20296             break;
20297         }
20298         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
20299         {
20300             VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
20301             const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header;
20302             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
20303             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
20304             out_header = (void *)out_ext;
20305             break;
20306         }
20307         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
20308         {
20309             VkPhysicalDeviceProtectedMemoryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
20310             const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header;
20311             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
20312             out_ext->protectedMemory = in_ext->protectedMemory;
20313             out_header = (void *)out_ext;
20314             break;
20315         }
20316         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
20317         {
20318             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT);
20319             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)in_header;
20320             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
20321             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
20322             out_header = (void *)out_ext;
20323             break;
20324         }
20325         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
20326         {
20327             VkPhysicalDeviceMultiDrawFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT);
20328             const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header;
20329             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
20330             out_ext->multiDraw = in_ext->multiDraw;
20331             out_header = (void *)out_ext;
20332             break;
20333         }
20334         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
20335         {
20336             VkPhysicalDeviceInlineUniformBlockFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES);
20337             const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header;
20338             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
20339             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
20340             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
20341             out_header = (void *)out_ext;
20342             break;
20343         }
20344         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
20345         {
20346             VkPhysicalDeviceMaintenance4Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES);
20347             const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header;
20348             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
20349             out_ext->maintenance4 = in_ext->maintenance4;
20350             out_header = (void *)out_ext;
20351             break;
20352         }
20353         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
20354         {
20355             VkPhysicalDeviceShaderDrawParametersFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
20356             const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header;
20357             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
20358             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
20359             out_header = (void *)out_ext;
20360             break;
20361         }
20362         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
20363         {
20364             VkPhysicalDeviceShaderFloat16Int8Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
20365             const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header;
20366             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
20367             out_ext->shaderFloat16 = in_ext->shaderFloat16;
20368             out_ext->shaderInt8 = in_ext->shaderInt8;
20369             out_header = (void *)out_ext;
20370             break;
20371         }
20372         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
20373         {
20374             VkPhysicalDeviceHostQueryResetFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
20375             const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header;
20376             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
20377             out_ext->hostQueryReset = in_ext->hostQueryReset;
20378             out_header = (void *)out_ext;
20379             break;
20380         }
20381         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
20382         {
20383             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR);
20384             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *)in_header;
20385             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
20386             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
20387             out_header = (void *)out_ext;
20388             break;
20389         }
20390         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
20391         {
20392             VkPhysicalDeviceDescriptorIndexingFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
20393             const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header;
20394             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
20395             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
20396             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
20397             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
20398             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
20399             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
20400             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
20401             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
20402             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
20403             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
20404             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
20405             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
20406             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
20407             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
20408             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
20409             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
20410             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
20411             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
20412             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
20413             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
20414             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
20415             out_header = (void *)out_ext;
20416             break;
20417         }
20418         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
20419         {
20420             VkPhysicalDeviceTimelineSemaphoreFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
20421             const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header;
20422             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
20423             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
20424             out_header = (void *)out_ext;
20425             break;
20426         }
20427         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
20428         {
20429             VkPhysicalDevice8BitStorageFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
20430             const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header;
20431             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
20432             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
20433             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
20434             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
20435             out_header = (void *)out_ext;
20436             break;
20437         }
20438         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
20439         {
20440             VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT);
20441             const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header;
20442             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
20443             out_ext->conditionalRendering = in_ext->conditionalRendering;
20444             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
20445             out_header = (void *)out_ext;
20446             break;
20447         }
20448         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
20449         {
20450             VkPhysicalDeviceVulkanMemoryModelFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
20451             const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header;
20452             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
20453             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
20454             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
20455             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
20456             out_header = (void *)out_ext;
20457             break;
20458         }
20459         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
20460         {
20461             VkPhysicalDeviceShaderAtomicInt64Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
20462             const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header;
20463             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
20464             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
20465             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
20466             out_header = (void *)out_ext;
20467             break;
20468         }
20469         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
20470         {
20471             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT);
20472             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header;
20473             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
20474             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
20475             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
20476             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
20477             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
20478             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
20479             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
20480             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
20481             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
20482             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
20483             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
20484             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
20485             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
20486             out_header = (void *)out_ext;
20487             break;
20488         }
20489         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
20490         {
20491             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT);
20492             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header;
20493             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
20494             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
20495             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
20496             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
20497             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
20498             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
20499             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
20500             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
20501             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
20502             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
20503             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
20504             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
20505             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
20506             out_header = (void *)out_ext;
20507             break;
20508         }
20509         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
20510         {
20511             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT);
20512             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)in_header;
20513             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
20514             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
20515             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
20516             out_header = (void *)out_ext;
20517             break;
20518         }
20519         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
20520         {
20521             VkPhysicalDeviceASTCDecodeFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT);
20522             const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header;
20523             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
20524             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
20525             out_header = (void *)out_ext;
20526             break;
20527         }
20528         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
20529         {
20530             VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
20531             const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header;
20532             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
20533             out_ext->transformFeedback = in_ext->transformFeedback;
20534             out_ext->geometryStreams = in_ext->geometryStreams;
20535             out_header = (void *)out_ext;
20536             break;
20537         }
20538         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
20539         {
20540             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV);
20541             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header;
20542             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
20543             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
20544             out_header = (void *)out_ext;
20545             break;
20546         }
20547         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
20548         {
20549             VkPhysicalDeviceExclusiveScissorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV);
20550             const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header;
20551             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
20552             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
20553             out_header = (void *)out_ext;
20554             break;
20555         }
20556         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
20557         {
20558             VkPhysicalDeviceCornerSampledImageFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV);
20559             const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header;
20560             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
20561             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
20562             out_header = (void *)out_ext;
20563             break;
20564         }
20565         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
20566         {
20567             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV);
20568             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *)in_header;
20569             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
20570             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
20571             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
20572             out_header = (void *)out_ext;
20573             break;
20574         }
20575         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
20576         {
20577             VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV);
20578             const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header;
20579             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
20580             out_ext->imageFootprint = in_ext->imageFootprint;
20581             out_header = (void *)out_ext;
20582             break;
20583         }
20584         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
20585         {
20586             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV);
20587             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header;
20588             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
20589             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
20590             out_header = (void *)out_ext;
20591             break;
20592         }
20593         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
20594         {
20595             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV);
20596             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header;
20597             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
20598             out_ext->indirectCopy = in_ext->indirectCopy;
20599             out_header = (void *)out_ext;
20600             break;
20601         }
20602         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
20603         {
20604             VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV);
20605             const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header;
20606             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
20607             out_ext->memoryDecompression = in_ext->memoryDecompression;
20608             out_header = (void *)out_ext;
20609             break;
20610         }
20611         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
20612         {
20613             VkPhysicalDeviceShadingRateImageFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV);
20614             const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header;
20615             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
20616             out_ext->shadingRateImage = in_ext->shadingRateImage;
20617             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
20618             out_header = (void *)out_ext;
20619             break;
20620         }
20621         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
20622         {
20623             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI);
20624             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header;
20625             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
20626             out_ext->invocationMask = in_ext->invocationMask;
20627             out_header = (void *)out_ext;
20628             break;
20629         }
20630         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
20631         {
20632             VkPhysicalDeviceMeshShaderFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV);
20633             const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header;
20634             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
20635             out_ext->taskShader = in_ext->taskShader;
20636             out_ext->meshShader = in_ext->meshShader;
20637             out_header = (void *)out_ext;
20638             break;
20639         }
20640         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
20641         {
20642             VkPhysicalDeviceMeshShaderFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT);
20643             const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header;
20644             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
20645             out_ext->taskShader = in_ext->taskShader;
20646             out_ext->meshShader = in_ext->meshShader;
20647             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
20648             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
20649             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
20650             out_header = (void *)out_ext;
20651             break;
20652         }
20653         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
20654         {
20655             VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR);
20656             const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header;
20657             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
20658             out_ext->accelerationStructure = in_ext->accelerationStructure;
20659             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
20660             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
20661             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
20662             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
20663             out_header = (void *)out_ext;
20664             break;
20665         }
20666         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
20667         {
20668             VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR);
20669             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header;
20670             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
20671             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
20672             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
20673             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
20674             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
20675             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
20676             out_header = (void *)out_ext;
20677             break;
20678         }
20679         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
20680         {
20681             VkPhysicalDeviceRayQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR);
20682             const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header;
20683             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
20684             out_ext->rayQuery = in_ext->rayQuery;
20685             out_header = (void *)out_ext;
20686             break;
20687         }
20688         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
20689         {
20690             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR);
20691             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header;
20692             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
20693             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
20694             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
20695             out_header = (void *)out_ext;
20696             break;
20697         }
20698         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
20699         {
20700             VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT);
20701             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)in_header;
20702             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
20703             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
20704             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
20705             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
20706             out_header = (void *)out_ext;
20707             break;
20708         }
20709         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
20710         {
20711             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT);
20712             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header;
20713             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
20714             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
20715             out_header = (void *)out_ext;
20716             break;
20717         }
20718         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
20719         {
20720             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM);
20721             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *)in_header;
20722             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
20723             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
20724             out_header = (void *)out_ext;
20725             break;
20726         }
20727         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
20728         {
20729             VkPhysicalDeviceScalarBlockLayoutFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
20730             const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header;
20731             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
20732             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
20733             out_header = (void *)out_ext;
20734             break;
20735         }
20736         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
20737         {
20738             VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
20739             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header;
20740             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
20741             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
20742             out_header = (void *)out_ext;
20743             break;
20744         }
20745         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
20746         {
20747             VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT);
20748             const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header;
20749             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
20750             out_ext->depthClipEnable = in_ext->depthClipEnable;
20751             out_header = (void *)out_ext;
20752             break;
20753         }
20754         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
20755         {
20756             VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT);
20757             const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header;
20758             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
20759             out_ext->memoryPriority = in_ext->memoryPriority;
20760             out_header = (void *)out_ext;
20761             break;
20762         }
20763         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
20764         {
20765             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT);
20766             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header;
20767             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
20768             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
20769             out_header = (void *)out_ext;
20770             break;
20771         }
20772         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
20773         {
20774             VkPhysicalDeviceBufferDeviceAddressFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
20775             const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header;
20776             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
20777             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
20778             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
20779             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
20780             out_header = (void *)out_ext;
20781             break;
20782         }
20783         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
20784         {
20785             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT);
20786             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header;
20787             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
20788             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
20789             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
20790             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
20791             out_header = (void *)out_ext;
20792             break;
20793         }
20794         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
20795         {
20796             VkPhysicalDeviceImagelessFramebufferFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
20797             const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header;
20798             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
20799             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
20800             out_header = (void *)out_ext;
20801             break;
20802         }
20803         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
20804         {
20805             VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES);
20806             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header;
20807             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
20808             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
20809             out_header = (void *)out_ext;
20810             break;
20811         }
20812         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
20813         {
20814             VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV);
20815             const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header;
20816             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
20817             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
20818             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
20819             out_header = (void *)out_ext;
20820             break;
20821         }
20822         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
20823         {
20824             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT);
20825             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header;
20826             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
20827             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
20828             out_header = (void *)out_ext;
20829             break;
20830         }
20831         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
20832         {
20833             VkPhysicalDevicePresentBarrierFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV);
20834             const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header;
20835             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
20836             out_ext->presentBarrier = in_ext->presentBarrier;
20837             out_header = (void *)out_ext;
20838             break;
20839         }
20840         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
20841         {
20842             VkPhysicalDevicePerformanceQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR);
20843             const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header;
20844             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
20845             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
20846             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
20847             out_header = (void *)out_ext;
20848             break;
20849         }
20850         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
20851         {
20852             VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV);
20853             const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header;
20854             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
20855             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
20856             out_header = (void *)out_ext;
20857             break;
20858         }
20859         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
20860         {
20861             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL);
20862             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header;
20863             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
20864             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
20865             out_header = (void *)out_ext;
20866             break;
20867         }
20868         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
20869         {
20870             VkPhysicalDeviceShaderClockFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR);
20871             const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header;
20872             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
20873             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
20874             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
20875             out_header = (void *)out_ext;
20876             break;
20877         }
20878         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
20879         {
20880             VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT);
20881             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)in_header;
20882             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
20883             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
20884             out_header = (void *)out_ext;
20885             break;
20886         }
20887         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
20888         {
20889             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV);
20890             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header;
20891             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
20892             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
20893             out_header = (void *)out_ext;
20894             break;
20895         }
20896         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
20897         {
20898             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT);
20899             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header;
20900             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
20901             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
20902             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
20903             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
20904             out_header = (void *)out_ext;
20905             break;
20906         }
20907         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
20908         {
20909             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
20910             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header;
20911             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
20912             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
20913             out_header = (void *)out_ext;
20914             break;
20915         }
20916         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
20917         {
20918             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT);
20919             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header;
20920             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
20921             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
20922             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
20923             out_header = (void *)out_ext;
20924             break;
20925         }
20926         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
20927         {
20928             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR);
20929             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header;
20930             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
20931             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
20932             out_header = (void *)out_ext;
20933             break;
20934         }
20935         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
20936         {
20937             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES);
20938             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header;
20939             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
20940             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
20941             out_header = (void *)out_ext;
20942             break;
20943         }
20944         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
20945         {
20946             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT);
20947             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header;
20948             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
20949             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
20950             out_header = (void *)out_ext;
20951             break;
20952         }
20953         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
20954         {
20955             VkPhysicalDeviceSubgroupSizeControlFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES);
20956             const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header;
20957             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
20958             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
20959             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
20960             out_header = (void *)out_ext;
20961             break;
20962         }
20963         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
20964         {
20965             VkPhysicalDeviceLineRasterizationFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT);
20966             const VkPhysicalDeviceLineRasterizationFeaturesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)in_header;
20967             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
20968             out_ext->rectangularLines = in_ext->rectangularLines;
20969             out_ext->bresenhamLines = in_ext->bresenhamLines;
20970             out_ext->smoothLines = in_ext->smoothLines;
20971             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
20972             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
20973             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
20974             out_header = (void *)out_ext;
20975             break;
20976         }
20977         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
20978         {
20979             VkPhysicalDevicePipelineCreationCacheControlFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES);
20980             const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header;
20981             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
20982             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
20983             out_header = (void *)out_ext;
20984             break;
20985         }
20986         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
20987         {
20988             VkPhysicalDeviceVulkan11Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
20989             const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header;
20990             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
20991             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
20992             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
20993             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
20994             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
20995             out_ext->multiview = in_ext->multiview;
20996             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
20997             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
20998             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
20999             out_ext->variablePointers = in_ext->variablePointers;
21000             out_ext->protectedMemory = in_ext->protectedMemory;
21001             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
21002             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
21003             out_header = (void *)out_ext;
21004             break;
21005         }
21006         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
21007         {
21008             VkPhysicalDeviceVulkan12Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
21009             const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header;
21010             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
21011             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
21012             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
21013             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
21014             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
21015             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
21016             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
21017             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
21018             out_ext->shaderFloat16 = in_ext->shaderFloat16;
21019             out_ext->shaderInt8 = in_ext->shaderInt8;
21020             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
21021             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
21022             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
21023             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
21024             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
21025             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
21026             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
21027             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
21028             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
21029             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
21030             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
21031             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
21032             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
21033             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
21034             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
21035             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
21036             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
21037             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
21038             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
21039             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
21040             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
21041             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
21042             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
21043             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
21044             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
21045             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
21046             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
21047             out_ext->hostQueryReset = in_ext->hostQueryReset;
21048             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
21049             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
21050             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
21051             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
21052             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
21053             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
21054             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
21055             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
21056             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
21057             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
21058             out_header = (void *)out_ext;
21059             break;
21060         }
21061         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
21062         {
21063             VkPhysicalDeviceVulkan13Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES);
21064             const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header;
21065             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
21066             out_ext->robustImageAccess = in_ext->robustImageAccess;
21067             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
21068             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
21069             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
21070             out_ext->privateData = in_ext->privateData;
21071             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
21072             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
21073             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
21074             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
21075             out_ext->synchronization2 = in_ext->synchronization2;
21076             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
21077             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
21078             out_ext->dynamicRendering = in_ext->dynamicRendering;
21079             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
21080             out_ext->maintenance4 = in_ext->maintenance4;
21081             out_header = (void *)out_ext;
21082             break;
21083         }
21084         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
21085         {
21086             VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD);
21087             const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header;
21088             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
21089             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
21090             out_header = (void *)out_ext;
21091             break;
21092         }
21093         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
21094         {
21095             VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT);
21096             const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header;
21097             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
21098             out_ext->customBorderColors = in_ext->customBorderColors;
21099             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
21100             out_header = (void *)out_ext;
21101             break;
21102         }
21103         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
21104         {
21105             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT);
21106             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header;
21107             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
21108             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
21109             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
21110             out_header = (void *)out_ext;
21111             break;
21112         }
21113         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
21114         {
21115             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT);
21116             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header;
21117             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
21118             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
21119             out_header = (void *)out_ext;
21120             break;
21121         }
21122         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
21123         {
21124             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT);
21125             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header;
21126             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
21127             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
21128             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
21129             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
21130             out_header = (void *)out_ext;
21131             break;
21132         }
21133         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
21134         {
21135             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT);
21136             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header;
21137             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
21138             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
21139             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
21140             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
21141             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
21142             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
21143             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
21144             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
21145             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
21146             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
21147             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
21148             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
21149             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
21150             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
21151             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
21152             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
21153             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
21154             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
21155             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
21156             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
21157             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
21158             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
21159             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
21160             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
21161             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
21162             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
21163             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
21164             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
21165             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
21166             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
21167             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
21168             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
21169             out_header = (void *)out_ext;
21170             break;
21171         }
21172         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
21173         {
21174             VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV);
21175             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header;
21176             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
21177             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
21178             out_header = (void *)out_ext;
21179             break;
21180         }
21181         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
21182         {
21183             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES);
21184             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header;
21185             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
21186             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
21187             out_header = (void *)out_ext;
21188             break;
21189         }
21190         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
21191         {
21192             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR);
21193             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header;
21194             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
21195             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
21196             out_header = (void *)out_ext;
21197             break;
21198         }
21199         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
21200         {
21201             VkPhysicalDeviceRobustness2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT);
21202             const VkPhysicalDeviceRobustness2FeaturesEXT *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT *)in_header;
21203             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
21204             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
21205             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
21206             out_ext->nullDescriptor = in_ext->nullDescriptor;
21207             out_header = (void *)out_ext;
21208             break;
21209         }
21210         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
21211         {
21212             VkPhysicalDeviceImageRobustnessFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES);
21213             const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header;
21214             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
21215             out_ext->robustImageAccess = in_ext->robustImageAccess;
21216             out_header = (void *)out_ext;
21217             break;
21218         }
21219         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
21220         {
21221             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR);
21222             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header;
21223             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
21224             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
21225             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
21226             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
21227             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
21228             out_header = (void *)out_ext;
21229             break;
21230         }
21231         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
21232         {
21233             VkPhysicalDevice4444FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT);
21234             const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header;
21235             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
21236             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
21237             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
21238             out_header = (void *)out_ext;
21239             break;
21240         }
21241         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
21242         {
21243             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI);
21244             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header;
21245             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
21246             out_ext->subpassShading = in_ext->subpassShading;
21247             out_header = (void *)out_ext;
21248             break;
21249         }
21250         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
21251         {
21252             VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI);
21253             const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *)in_header;
21254             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
21255             out_ext->clustercullingShader = in_ext->clustercullingShader;
21256             out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
21257             out_header = (void *)out_ext;
21258             break;
21259         }
21260         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
21261         {
21262             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT);
21263             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header;
21264             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
21265             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
21266             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
21267             out_header = (void *)out_ext;
21268             break;
21269         }
21270         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
21271         {
21272             VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR);
21273             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header;
21274             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
21275             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
21276             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
21277             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
21278             out_header = (void *)out_ext;
21279             break;
21280         }
21281         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
21282         {
21283             VkPhysicalDeviceShaderTerminateInvocationFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES);
21284             const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header;
21285             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
21286             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
21287             out_header = (void *)out_ext;
21288             break;
21289         }
21290         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
21291         {
21292             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV);
21293             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header;
21294             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
21295             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
21296             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
21297             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
21298             out_header = (void *)out_ext;
21299             break;
21300         }
21301         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
21302         {
21303             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT);
21304             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header;
21305             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
21306             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
21307             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
21308             out_header = (void *)out_ext;
21309             break;
21310         }
21311         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
21312         {
21313             VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT);
21314             const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *)in_header;
21315             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
21316             out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
21317             out_header = (void *)out_ext;
21318             break;
21319         }
21320         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
21321         {
21322             VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT);
21323             const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *)in_header;
21324             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
21325             out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
21326             out_header = (void *)out_ext;
21327             break;
21328         }
21329         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
21330         {
21331             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT);
21332             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header;
21333             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
21334             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
21335             out_header = (void *)out_ext;
21336             break;
21337         }
21338         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
21339         {
21340             VkPhysicalDeviceDepthClipControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT);
21341             const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header;
21342             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
21343             out_ext->depthClipControl = in_ext->depthClipControl;
21344             out_header = (void *)out_ext;
21345             break;
21346         }
21347         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
21348         {
21349             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT);
21350             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header;
21351             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
21352             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
21353             out_header = (void *)out_ext;
21354             break;
21355         }
21356         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
21357         {
21358             VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT);
21359             const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header;
21360             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
21361             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
21362             out_header = (void *)out_ext;
21363             break;
21364         }
21365         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
21366         {
21367             VkPhysicalDeviceSynchronization2Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES);
21368             const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header;
21369             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
21370             out_ext->synchronization2 = in_ext->synchronization2;
21371             out_header = (void *)out_ext;
21372             break;
21373         }
21374         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
21375         {
21376             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT);
21377             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header;
21378             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
21379             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
21380             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
21381             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
21382             out_header = (void *)out_ext;
21383             break;
21384         }
21385         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
21386         {
21387             VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT);
21388             const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header;
21389             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
21390             out_ext->legacyDithering = in_ext->legacyDithering;
21391             out_header = (void *)out_ext;
21392             break;
21393         }
21394         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
21395         {
21396             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT);
21397             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header;
21398             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
21399             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
21400             out_header = (void *)out_ext;
21401             break;
21402         }
21403         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
21404         {
21405             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT);
21406             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *)in_header;
21407             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
21408             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
21409             out_header = (void *)out_ext;
21410             break;
21411         }
21412         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
21413         {
21414             VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV);
21415             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header;
21416             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
21417             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
21418             out_header = (void *)out_ext;
21419             break;
21420         }
21421         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
21422         {
21423             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT);
21424             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header;
21425             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
21426             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
21427             out_header = (void *)out_ext;
21428             break;
21429         }
21430         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
21431         {
21432             VkPhysicalDeviceProvokingVertexFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT);
21433             const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header;
21434             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
21435             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
21436             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
21437             out_header = (void *)out_ext;
21438             break;
21439         }
21440         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
21441         {
21442             VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT);
21443             const VkPhysicalDeviceDescriptorBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)in_header;
21444             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
21445             out_ext->descriptorBuffer = in_ext->descriptorBuffer;
21446             out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
21447             out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
21448             out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
21449             out_header = (void *)out_ext;
21450             break;
21451         }
21452         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
21453         {
21454             VkPhysicalDeviceShaderIntegerDotProductFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES);
21455             const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header;
21456             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
21457             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
21458             out_header = (void *)out_ext;
21459             break;
21460         }
21461         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
21462         {
21463             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR);
21464             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header;
21465             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
21466             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
21467             out_header = (void *)out_ext;
21468             break;
21469         }
21470         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
21471         {
21472             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV);
21473             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header;
21474             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
21475             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
21476             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
21477             out_header = (void *)out_ext;
21478             break;
21479         }
21480         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
21481         {
21482             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT);
21483             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header;
21484             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
21485             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
21486             out_header = (void *)out_ext;
21487             break;
21488         }
21489         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
21490         {
21491             VkPhysicalDeviceDynamicRenderingFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES);
21492             const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header;
21493             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
21494             out_ext->dynamicRendering = in_ext->dynamicRendering;
21495             out_header = (void *)out_ext;
21496             break;
21497         }
21498         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
21499         {
21500             VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT);
21501             const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header;
21502             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
21503             out_ext->minLod = in_ext->minLod;
21504             out_header = (void *)out_ext;
21505             break;
21506         }
21507         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
21508         {
21509             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT);
21510             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header;
21511             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
21512             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
21513             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
21514             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
21515             out_header = (void *)out_ext;
21516             break;
21517         }
21518         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
21519         {
21520             VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV);
21521             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header;
21522             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
21523             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
21524             out_header = (void *)out_ext;
21525             break;
21526         }
21527         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
21528         {
21529             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT);
21530             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header;
21531             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
21532             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
21533             out_header = (void *)out_ext;
21534             break;
21535         }
21536         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
21537         {
21538             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE);
21539             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header;
21540             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
21541             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
21542             out_header = (void *)out_ext;
21543             break;
21544         }
21545         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
21546         {
21547             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT);
21548             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header;
21549             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
21550             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
21551             out_header = (void *)out_ext;
21552             break;
21553         }
21554         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
21555         {
21556             VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT);
21557             const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header;
21558             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
21559             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
21560             out_header = (void *)out_ext;
21561             break;
21562         }
21563         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
21564         {
21565             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT);
21566             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header;
21567             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
21568             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
21569             out_header = (void *)out_ext;
21570             break;
21571         }
21572         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
21573         {
21574             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT);
21575             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header;
21576             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
21577             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
21578             out_header = (void *)out_ext;
21579             break;
21580         }
21581         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
21582         {
21583             VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT);
21584             const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header;
21585             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
21586             out_ext->micromap = in_ext->micromap;
21587             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
21588             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
21589             out_header = (void *)out_ext;
21590             break;
21591         }
21592         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
21593         {
21594             VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT);
21595             const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header;
21596             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
21597             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
21598             out_header = (void *)out_ext;
21599             break;
21600         }
21601         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
21602         {
21603             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD);
21604             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *)in_header;
21605             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
21606             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
21607             out_header = (void *)out_ext;
21608             break;
21609         }
21610         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
21611         {
21612             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT);
21613             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header;
21614             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
21615             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
21616             out_header = (void *)out_ext;
21617             break;
21618         }
21619         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
21620         {
21621             VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT);
21622             const VkPhysicalDevicePipelineRobustnessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT *)in_header;
21623             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
21624             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
21625             out_header = (void *)out_ext;
21626             break;
21627         }
21628         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
21629         {
21630             VkPhysicalDeviceImageProcessingFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM);
21631             const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header;
21632             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
21633             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
21634             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
21635             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
21636             out_header = (void *)out_ext;
21637             break;
21638         }
21639         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
21640         {
21641             VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM);
21642             const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header;
21643             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
21644             out_ext->tileProperties = in_ext->tileProperties;
21645             out_header = (void *)out_ext;
21646             break;
21647         }
21648         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
21649         {
21650             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT);
21651             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header;
21652             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
21653             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
21654             out_header = (void *)out_ext;
21655             break;
21656         }
21657         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
21658         {
21659             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT);
21660             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *)in_header;
21661             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
21662             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
21663             out_header = (void *)out_ext;
21664             break;
21665         }
21666         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
21667         {
21668             VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT);
21669             const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header;
21670             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
21671             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
21672             out_header = (void *)out_ext;
21673             break;
21674         }
21675         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
21676         {
21677             VkPhysicalDeviceOpticalFlowFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV);
21678             const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header;
21679             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
21680             out_ext->opticalFlow = in_ext->opticalFlow;
21681             out_header = (void *)out_ext;
21682             break;
21683         }
21684         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
21685         {
21686             VkPhysicalDeviceFaultFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT);
21687             const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header;
21688             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
21689             out_ext->deviceFault = in_ext->deviceFault;
21690             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
21691             out_header = (void *)out_ext;
21692             break;
21693         }
21694         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
21695         {
21696             VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT);
21697             const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *)in_header;
21698             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
21699             out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
21700             out_header = (void *)out_ext;
21701             break;
21702         }
21703         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
21704         {
21705             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM);
21706             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header;
21707             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
21708             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
21709             out_header = (void *)out_ext;
21710             break;
21711         }
21712         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
21713         {
21714             VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT);
21715             const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *)in_header;
21716             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT;
21717             out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
21718             out_header = (void *)out_ext;
21719             break;
21720         }
21721         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
21722         {
21723             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV);
21724             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header;
21725             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
21726             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
21727             out_header = (void *)out_ext;
21728             break;
21729         }
21730         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
21731         {
21732             VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM);
21733             const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *)in_header;
21734             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
21735             out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
21736             out_header = (void *)out_ext;
21737             break;
21738         }
21739         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
21740         {
21741             VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR);
21742             const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *)in_header;
21743             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
21744             out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
21745             out_header = (void *)out_ext;
21746             break;
21747         }
21748         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
21749         {
21750             VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM);
21751             const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *)in_header;
21752             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
21753             out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
21754             out_header = (void *)out_ext;
21755             break;
21756         }
21757         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
21758         {
21759             VkPhysicalDeviceShaderObjectFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT);
21760             const VkPhysicalDeviceShaderObjectFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT *)in_header;
21761             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
21762             out_ext->shaderObject = in_ext->shaderObject;
21763             out_header = (void *)out_ext;
21764             break;
21765         }
21766         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
21767         {
21768             VkPhysicalDeviceShaderTileImageFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT);
21769             const VkPhysicalDeviceShaderTileImageFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT *)in_header;
21770             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
21771             out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess;
21772             out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess;
21773             out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess;
21774             out_header = (void *)out_ext;
21775             break;
21776         }
21777         default:
21778             break;
21779         }
21780     }
21781 }
21782
21783 static inline void convert_VkFormatProperties2_win32_to_host(struct conversion_context *ctx, const VkFormatProperties232 *in, VkFormatProperties2 *out)
21784 {
21785     const VkBaseInStructure32 *in_header;
21786     VkBaseOutStructure *out_header = (void *)out;
21787
21788     if (!in) return;
21789
21790     out->sType = in->sType;
21791     out->pNext = NULL;
21792
21793     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
21794     {
21795         switch (in_header->sType)
21796         {
21797         case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
21798         {
21799             VkSubpassResolvePerformanceQueryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21800             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
21801             out_ext->pNext = NULL;
21802             out_header->pNext = (void *)out_ext;
21803             out_header = (void *)out_ext;
21804             break;
21805         }
21806         case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
21807         {
21808             VkFormatProperties3 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21809             out_ext->sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
21810             out_ext->pNext = NULL;
21811             out_header->pNext = (void *)out_ext;
21812             out_header = (void *)out_ext;
21813             break;
21814         }
21815         default:
21816             FIXME("Unhandled sType %u.\n", in_header->sType);
21817             break;
21818         }
21819     }
21820 }
21821
21822 static inline void convert_VkFormatProperties2_host_to_win32(const VkFormatProperties2 *in, VkFormatProperties232 *out)
21823 {
21824     const VkBaseInStructure *in_header;
21825     VkBaseOutStructure32 *out_header = (void *)out;
21826
21827     if (!in) return;
21828
21829     out->formatProperties = in->formatProperties;
21830
21831     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
21832     {
21833         switch (in_header->sType)
21834         {
21835         case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
21836         {
21837             VkSubpassResolvePerformanceQueryEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT);
21838             const VkSubpassResolvePerformanceQueryEXT *in_ext = (const VkSubpassResolvePerformanceQueryEXT *)in_header;
21839             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
21840             out_ext->optimal = in_ext->optimal;
21841             out_header = (void *)out_ext;
21842             break;
21843         }
21844         case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
21845         {
21846             VkFormatProperties332 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3);
21847             const VkFormatProperties3 *in_ext = (const VkFormatProperties3 *)in_header;
21848             out_ext->sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
21849             out_ext->linearTilingFeatures = in_ext->linearTilingFeatures;
21850             out_ext->optimalTilingFeatures = in_ext->optimalTilingFeatures;
21851             out_ext->bufferFeatures = in_ext->bufferFeatures;
21852             out_header = (void *)out_ext;
21853             break;
21854         }
21855         default:
21856             break;
21857         }
21858     }
21859 }
21860
21861 static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_win32_to_host(const VkPhysicalDeviceFragmentShadingRateKHR32 *in, VkPhysicalDeviceFragmentShadingRateKHR *out)
21862 {
21863     if (!in) return;
21864
21865     out->sType = in->sType;
21866     out->pNext = NULL;
21867     if (in->pNext)
21868         FIXME("Unexpected pNext\n");
21869 }
21870
21871 static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_host_to_win32(const VkPhysicalDeviceFragmentShadingRateKHR *in, VkPhysicalDeviceFragmentShadingRateKHR32 *out)
21872 {
21873     if (!in) return;
21874
21875     out->sampleCounts = in->sampleCounts;
21876     out->fragmentSize = in->fragmentSize;
21877 }
21878
21879 static inline VkPhysicalDeviceFragmentShadingRateKHR *convert_VkPhysicalDeviceFragmentShadingRateKHR_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceFragmentShadingRateKHR32 *in, uint32_t count)
21880 {
21881     VkPhysicalDeviceFragmentShadingRateKHR *out;
21882     unsigned int i;
21883
21884     if (!in || !count) return NULL;
21885
21886     out = conversion_context_alloc(ctx, count * sizeof(*out));
21887     for (i = 0; i < count; i++)
21888     {
21889         convert_VkPhysicalDeviceFragmentShadingRateKHR_win32_to_host(&in[i], &out[i]);
21890     }
21891
21892     return out;
21893 }
21894
21895 static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_array_host_to_win32(const VkPhysicalDeviceFragmentShadingRateKHR *in, VkPhysicalDeviceFragmentShadingRateKHR32 *out, uint32_t count)
21896 {
21897     unsigned int i;
21898
21899     if (!in) return;
21900
21901     for (i = 0; i < count; i++)
21902     {
21903         convert_VkPhysicalDeviceFragmentShadingRateKHR_host_to_win32(&in[i], &out[i]);
21904     }
21905 }
21906
21907 static inline void convert_VkImageFormatProperties_host_to_win32(const VkImageFormatProperties *in, VkImageFormatProperties32 *out)
21908 {
21909     if (!in) return;
21910
21911     out->maxExtent = in->maxExtent;
21912     out->maxMipLevels = in->maxMipLevels;
21913     out->maxArrayLayers = in->maxArrayLayers;
21914     out->sampleCounts = in->sampleCounts;
21915     out->maxResourceSize = in->maxResourceSize;
21916 }
21917
21918 static inline void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceImageFormatInfo232 *in, VkPhysicalDeviceImageFormatInfo2 *out)
21919 {
21920     const VkBaseInStructure32 *in_header;
21921     VkBaseOutStructure *out_header = (void *)out;
21922
21923     if (!in) return;
21924
21925     out->sType = in->sType;
21926     out->pNext = NULL;
21927     out->format = in->format;
21928     out->type = in->type;
21929     out->tiling = in->tiling;
21930     out->usage = in->usage;
21931     out->flags = in->flags;
21932
21933     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
21934     {
21935         switch (in_header->sType)
21936         {
21937         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
21938         {
21939             VkPhysicalDeviceExternalImageFormatInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21940             const VkPhysicalDeviceExternalImageFormatInfo32 *in_ext = (const VkPhysicalDeviceExternalImageFormatInfo32 *)in_header;
21941             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
21942             out_ext->pNext = NULL;
21943             out_ext->handleType = in_ext->handleType;
21944             out_header->pNext = (void *)out_ext;
21945             out_header = (void *)out_ext;
21946             break;
21947         }
21948         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
21949         {
21950             VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21951             const VkImageFormatListCreateInfo32 *in_ext = (const VkImageFormatListCreateInfo32 *)in_header;
21952             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
21953             out_ext->pNext = NULL;
21954             out_ext->viewFormatCount = in_ext->viewFormatCount;
21955             out_ext->pViewFormats = (const VkFormat *)UlongToPtr(in_ext->pViewFormats);
21956             out_header->pNext = (void *)out_ext;
21957             out_header = (void *)out_ext;
21958             break;
21959         }
21960         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
21961         {
21962             VkImageStencilUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21963             const VkImageStencilUsageCreateInfo32 *in_ext = (const VkImageStencilUsageCreateInfo32 *)in_header;
21964             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO;
21965             out_ext->pNext = NULL;
21966             out_ext->stencilUsage = in_ext->stencilUsage;
21967             out_header->pNext = (void *)out_ext;
21968             out_header = (void *)out_ext;
21969             break;
21970         }
21971         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
21972         {
21973             VkPhysicalDeviceImageViewImageFormatInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21974             const VkPhysicalDeviceImageViewImageFormatInfoEXT32 *in_ext = (const VkPhysicalDeviceImageViewImageFormatInfoEXT32 *)in_header;
21975             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT;
21976             out_ext->pNext = NULL;
21977             out_ext->imageViewType = in_ext->imageViewType;
21978             out_header->pNext = (void *)out_ext;
21979             out_header = (void *)out_ext;
21980             break;
21981         }
21982         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
21983         {
21984             VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21985             const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
21986             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
21987             out_ext->pNext = NULL;
21988             out_ext->flags = in_ext->flags;
21989             out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
21990             out_ext->pFixedRateFlags = (VkImageCompressionFixedRateFlagsEXT *)UlongToPtr(in_ext->pFixedRateFlags);
21991             out_header->pNext = (void *)out_ext;
21992             out_header = (void *)out_ext;
21993             break;
21994         }
21995         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
21996         {
21997             VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21998             const VkOpticalFlowImageFormatInfoNV32 *in_ext = (const VkOpticalFlowImageFormatInfoNV32 *)in_header;
21999             out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV;
22000             out_ext->pNext = NULL;
22001             out_ext->usage = in_ext->usage;
22002             out_header->pNext = (void *)out_ext;
22003             out_header = (void *)out_ext;
22004             break;
22005         }
22006         default:
22007             FIXME("Unhandled sType %u.\n", in_header->sType);
22008             break;
22009         }
22010     }
22011 }
22012
22013 static inline void convert_VkImageFormatProperties2_win32_to_host(struct conversion_context *ctx, const VkImageFormatProperties232 *in, VkImageFormatProperties2 *out)
22014 {
22015     const VkBaseInStructure32 *in_header;
22016     VkBaseOutStructure *out_header = (void *)out;
22017
22018     if (!in) return;
22019
22020     out->sType = in->sType;
22021     out->pNext = NULL;
22022
22023     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
22024     {
22025         switch (in_header->sType)
22026         {
22027         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
22028         {
22029             VkExternalImageFormatProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22030             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
22031             out_ext->pNext = NULL;
22032             out_header->pNext = (void *)out_ext;
22033             out_header = (void *)out_ext;
22034             break;
22035         }
22036         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
22037         {
22038             VkSamplerYcbcrConversionImageFormatProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22039             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
22040             out_ext->pNext = NULL;
22041             out_header->pNext = (void *)out_ext;
22042             out_header = (void *)out_ext;
22043             break;
22044         }
22045         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
22046         {
22047             VkTextureLODGatherFormatPropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22048             out_ext->sType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD;
22049             out_ext->pNext = NULL;
22050             out_header->pNext = (void *)out_ext;
22051             out_header = (void *)out_ext;
22052             break;
22053         }
22054         case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
22055         {
22056             VkFilterCubicImageViewImageFormatPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22057             out_ext->sType = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT;
22058             out_ext->pNext = NULL;
22059             out_header->pNext = (void *)out_ext;
22060             out_header = (void *)out_ext;
22061             break;
22062         }
22063         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
22064         {
22065             VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22066             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
22067             out_ext->pNext = NULL;
22068             out_header->pNext = (void *)out_ext;
22069             out_header = (void *)out_ext;
22070             break;
22071         }
22072         default:
22073             FIXME("Unhandled sType %u.\n", in_header->sType);
22074             break;
22075         }
22076     }
22077 }
22078
22079 static inline void convert_VkImageFormatProperties2_host_to_win32(const VkImageFormatProperties2 *in, VkImageFormatProperties232 *out)
22080 {
22081     const VkBaseInStructure *in_header;
22082     VkBaseOutStructure32 *out_header = (void *)out;
22083
22084     if (!in) return;
22085
22086     convert_VkImageFormatProperties_host_to_win32(&in->imageFormatProperties, &out->imageFormatProperties);
22087
22088     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
22089     {
22090         switch (in_header->sType)
22091         {
22092         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
22093         {
22094             VkExternalImageFormatProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
22095             const VkExternalImageFormatProperties *in_ext = (const VkExternalImageFormatProperties *)in_header;
22096             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
22097             out_ext->externalMemoryProperties = in_ext->externalMemoryProperties;
22098             out_header = (void *)out_ext;
22099             break;
22100         }
22101         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
22102         {
22103             VkSamplerYcbcrConversionImageFormatProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
22104             const VkSamplerYcbcrConversionImageFormatProperties *in_ext = (const VkSamplerYcbcrConversionImageFormatProperties *)in_header;
22105             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
22106             out_ext->combinedImageSamplerDescriptorCount = in_ext->combinedImageSamplerDescriptorCount;
22107             out_header = (void *)out_ext;
22108             break;
22109         }
22110         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
22111         {
22112             VkTextureLODGatherFormatPropertiesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD);
22113             const VkTextureLODGatherFormatPropertiesAMD *in_ext = (const VkTextureLODGatherFormatPropertiesAMD *)in_header;
22114             out_ext->sType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD;
22115             out_ext->supportsTextureGatherLODBiasAMD = in_ext->supportsTextureGatherLODBiasAMD;
22116             out_header = (void *)out_ext;
22117             break;
22118         }
22119         case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
22120         {
22121             VkFilterCubicImageViewImageFormatPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT);
22122             const VkFilterCubicImageViewImageFormatPropertiesEXT *in_ext = (const VkFilterCubicImageViewImageFormatPropertiesEXT *)in_header;
22123             out_ext->sType = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT;
22124             out_ext->filterCubic = in_ext->filterCubic;
22125             out_ext->filterCubicMinmax = in_ext->filterCubicMinmax;
22126             out_header = (void *)out_ext;
22127             break;
22128         }
22129         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
22130         {
22131             VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT);
22132             const VkImageCompressionPropertiesEXT *in_ext = (const VkImageCompressionPropertiesEXT *)in_header;
22133             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
22134             out_ext->imageCompressionFlags = in_ext->imageCompressionFlags;
22135             out_ext->imageCompressionFixedRateFlags = in_ext->imageCompressionFixedRateFlags;
22136             out_header = (void *)out_ext;
22137             break;
22138         }
22139         default:
22140             break;
22141         }
22142     }
22143 }
22144
22145 static inline void convert_VkMemoryHeap_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out)
22146 {
22147     if (!in) return;
22148
22149     out->size = in->size;
22150     out->flags = in->flags;
22151 }
22152
22153 static inline void convert_VkMemoryHeap_array_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out, uint32_t count)
22154 {
22155     unsigned int i;
22156
22157     if (!in) return;
22158
22159     for (i = 0; i < count; i++)
22160     {
22161         convert_VkMemoryHeap_host_to_win32(&in[i], &out[i]);
22162     }
22163 }
22164
22165 static inline void convert_VkPhysicalDeviceMemoryProperties_host_to_win32(const VkPhysicalDeviceMemoryProperties *in, VkPhysicalDeviceMemoryProperties32 *out)
22166 {
22167     if (!in) return;
22168
22169     out->memoryTypeCount = in->memoryTypeCount;
22170     memcpy(out->memoryTypes, in->memoryTypes, VK_MAX_MEMORY_TYPES * sizeof(VkMemoryType));
22171     out->memoryHeapCount = in->memoryHeapCount;
22172     convert_VkMemoryHeap_array_host_to_win32(in->memoryHeaps, out->memoryHeaps, VK_MAX_MEMORY_HEAPS);
22173 }
22174
22175 static inline void convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceMemoryProperties232 *in, VkPhysicalDeviceMemoryProperties2 *out)
22176 {
22177     const VkBaseInStructure32 *in_header;
22178     VkBaseOutStructure *out_header = (void *)out;
22179
22180     if (!in) return;
22181
22182     out->sType = in->sType;
22183     out->pNext = NULL;
22184
22185     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
22186     {
22187         switch (in_header->sType)
22188         {
22189         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
22190         {
22191             VkPhysicalDeviceMemoryBudgetPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22192             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
22193             out_ext->pNext = NULL;
22194             out_header->pNext = (void *)out_ext;
22195             out_header = (void *)out_ext;
22196             break;
22197         }
22198         default:
22199             FIXME("Unhandled sType %u.\n", in_header->sType);
22200             break;
22201         }
22202     }
22203 }
22204
22205 static inline void convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(const VkPhysicalDeviceMemoryProperties2 *in, VkPhysicalDeviceMemoryProperties232 *out)
22206 {
22207     const VkBaseInStructure *in_header;
22208     VkBaseOutStructure32 *out_header = (void *)out;
22209
22210     if (!in) return;
22211
22212     convert_VkPhysicalDeviceMemoryProperties_host_to_win32(&in->memoryProperties, &out->memoryProperties);
22213
22214     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
22215     {
22216         switch (in_header->sType)
22217         {
22218         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
22219         {
22220             VkPhysicalDeviceMemoryBudgetPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT);
22221             const VkPhysicalDeviceMemoryBudgetPropertiesEXT *in_ext = (const VkPhysicalDeviceMemoryBudgetPropertiesEXT *)in_header;
22222             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
22223             memcpy(out_ext->heapBudget, in_ext->heapBudget, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
22224             memcpy(out_ext->heapUsage, in_ext->heapUsage, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
22225             out_header = (void *)out_ext;
22226             break;
22227         }
22228         default:
22229             break;
22230         }
22231     }
22232 }
22233
22234 static inline void convert_VkMultisamplePropertiesEXT_win32_to_host(const VkMultisamplePropertiesEXT32 *in, VkMultisamplePropertiesEXT *out)
22235 {
22236     if (!in) return;
22237
22238     out->sType = in->sType;
22239     out->pNext = NULL;
22240     if (in->pNext)
22241         FIXME("Unexpected pNext\n");
22242 }
22243
22244 static inline void convert_VkMultisamplePropertiesEXT_host_to_win32(const VkMultisamplePropertiesEXT *in, VkMultisamplePropertiesEXT32 *out)
22245 {
22246     if (!in) return;
22247
22248     out->maxSampleLocationGridSize = in->maxSampleLocationGridSize;
22249 }
22250
22251 static inline void convert_VkOpticalFlowImageFormatInfoNV_win32_to_host(const VkOpticalFlowImageFormatInfoNV32 *in, VkOpticalFlowImageFormatInfoNV *out)
22252 {
22253     if (!in) return;
22254
22255     out->sType = in->sType;
22256     out->pNext = NULL;
22257     out->usage = in->usage;
22258     if (in->pNext)
22259         FIXME("Unexpected pNext\n");
22260 }
22261
22262 static inline void convert_VkOpticalFlowImageFormatPropertiesNV_win32_to_host(const VkOpticalFlowImageFormatPropertiesNV32 *in, VkOpticalFlowImageFormatPropertiesNV *out)
22263 {
22264     if (!in) return;
22265
22266     out->sType = in->sType;
22267     out->pNext = NULL;
22268     if (in->pNext)
22269         FIXME("Unexpected pNext\n");
22270 }
22271
22272 static inline void convert_VkOpticalFlowImageFormatPropertiesNV_host_to_win32(const VkOpticalFlowImageFormatPropertiesNV *in, VkOpticalFlowImageFormatPropertiesNV32 *out)
22273 {
22274     if (!in) return;
22275
22276     out->format = in->format;
22277 }
22278
22279 static inline VkOpticalFlowImageFormatPropertiesNV *convert_VkOpticalFlowImageFormatPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkOpticalFlowImageFormatPropertiesNV32 *in, uint32_t count)
22280 {
22281     VkOpticalFlowImageFormatPropertiesNV *out;
22282     unsigned int i;
22283
22284     if (!in || !count) return NULL;
22285
22286     out = conversion_context_alloc(ctx, count * sizeof(*out));
22287     for (i = 0; i < count; i++)
22288     {
22289         convert_VkOpticalFlowImageFormatPropertiesNV_win32_to_host(&in[i], &out[i]);
22290     }
22291
22292     return out;
22293 }
22294
22295 static inline void convert_VkOpticalFlowImageFormatPropertiesNV_array_host_to_win32(const VkOpticalFlowImageFormatPropertiesNV *in, VkOpticalFlowImageFormatPropertiesNV32 *out, uint32_t count)
22296 {
22297     unsigned int i;
22298
22299     if (!in) return;
22300
22301     for (i = 0; i < count; i++)
22302     {
22303         convert_VkOpticalFlowImageFormatPropertiesNV_host_to_win32(&in[i], &out[i]);
22304     }
22305 }
22306
22307 static inline void convert_VkPhysicalDeviceLimits_host_to_win32(const VkPhysicalDeviceLimits *in, VkPhysicalDeviceLimits32 *out)
22308 {
22309     if (!in) return;
22310
22311     out->maxImageDimension1D = in->maxImageDimension1D;
22312     out->maxImageDimension2D = in->maxImageDimension2D;
22313     out->maxImageDimension3D = in->maxImageDimension3D;
22314     out->maxImageDimensionCube = in->maxImageDimensionCube;
22315     out->maxImageArrayLayers = in->maxImageArrayLayers;
22316     out->maxTexelBufferElements = in->maxTexelBufferElements;
22317     out->maxUniformBufferRange = in->maxUniformBufferRange;
22318     out->maxStorageBufferRange = in->maxStorageBufferRange;
22319     out->maxPushConstantsSize = in->maxPushConstantsSize;
22320     out->maxMemoryAllocationCount = in->maxMemoryAllocationCount;
22321     out->maxSamplerAllocationCount = in->maxSamplerAllocationCount;
22322     out->bufferImageGranularity = in->bufferImageGranularity;
22323     out->sparseAddressSpaceSize = in->sparseAddressSpaceSize;
22324     out->maxBoundDescriptorSets = in->maxBoundDescriptorSets;
22325     out->maxPerStageDescriptorSamplers = in->maxPerStageDescriptorSamplers;
22326     out->maxPerStageDescriptorUniformBuffers = in->maxPerStageDescriptorUniformBuffers;
22327     out->maxPerStageDescriptorStorageBuffers = in->maxPerStageDescriptorStorageBuffers;
22328     out->maxPerStageDescriptorSampledImages = in->maxPerStageDescriptorSampledImages;
22329     out->maxPerStageDescriptorStorageImages = in->maxPerStageDescriptorStorageImages;
22330     out->maxPerStageDescriptorInputAttachments = in->maxPerStageDescriptorInputAttachments;
22331     out->maxPerStageResources = in->maxPerStageResources;
22332     out->maxDescriptorSetSamplers = in->maxDescriptorSetSamplers;
22333     out->maxDescriptorSetUniformBuffers = in->maxDescriptorSetUniformBuffers;
22334     out->maxDescriptorSetUniformBuffersDynamic = in->maxDescriptorSetUniformBuffersDynamic;
22335     out->maxDescriptorSetStorageBuffers = in->maxDescriptorSetStorageBuffers;
22336     out->maxDescriptorSetStorageBuffersDynamic = in->maxDescriptorSetStorageBuffersDynamic;
22337     out->maxDescriptorSetSampledImages = in->maxDescriptorSetSampledImages;
22338     out->maxDescriptorSetStorageImages = in->maxDescriptorSetStorageImages;
22339     out->maxDescriptorSetInputAttachments = in->maxDescriptorSetInputAttachments;
22340     out->maxVertexInputAttributes = in->maxVertexInputAttributes;
22341     out->maxVertexInputBindings = in->maxVertexInputBindings;
22342     out->maxVertexInputAttributeOffset = in->maxVertexInputAttributeOffset;
22343     out->maxVertexInputBindingStride = in->maxVertexInputBindingStride;
22344     out->maxVertexOutputComponents = in->maxVertexOutputComponents;
22345     out->maxTessellationGenerationLevel = in->maxTessellationGenerationLevel;
22346     out->maxTessellationPatchSize = in->maxTessellationPatchSize;
22347     out->maxTessellationControlPerVertexInputComponents = in->maxTessellationControlPerVertexInputComponents;
22348     out->maxTessellationControlPerVertexOutputComponents = in->maxTessellationControlPerVertexOutputComponents;
22349     out->maxTessellationControlPerPatchOutputComponents = in->maxTessellationControlPerPatchOutputComponents;
22350     out->maxTessellationControlTotalOutputComponents = in->maxTessellationControlTotalOutputComponents;
22351     out->maxTessellationEvaluationInputComponents = in->maxTessellationEvaluationInputComponents;
22352     out->maxTessellationEvaluationOutputComponents = in->maxTessellationEvaluationOutputComponents;
22353     out->maxGeometryShaderInvocations = in->maxGeometryShaderInvocations;
22354     out->maxGeometryInputComponents = in->maxGeometryInputComponents;
22355     out->maxGeometryOutputComponents = in->maxGeometryOutputComponents;
22356     out->maxGeometryOutputVertices = in->maxGeometryOutputVertices;
22357     out->maxGeometryTotalOutputComponents = in->maxGeometryTotalOutputComponents;
22358     out->maxFragmentInputComponents = in->maxFragmentInputComponents;
22359     out->maxFragmentOutputAttachments = in->maxFragmentOutputAttachments;
22360     out->maxFragmentDualSrcAttachments = in->maxFragmentDualSrcAttachments;
22361     out->maxFragmentCombinedOutputResources = in->maxFragmentCombinedOutputResources;
22362     out->maxComputeSharedMemorySize = in->maxComputeSharedMemorySize;
22363     memcpy(out->maxComputeWorkGroupCount, in->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
22364     out->maxComputeWorkGroupInvocations = in->maxComputeWorkGroupInvocations;
22365     memcpy(out->maxComputeWorkGroupSize, in->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
22366     out->subPixelPrecisionBits = in->subPixelPrecisionBits;
22367     out->subTexelPrecisionBits = in->subTexelPrecisionBits;
22368     out->mipmapPrecisionBits = in->mipmapPrecisionBits;
22369     out->maxDrawIndexedIndexValue = in->maxDrawIndexedIndexValue;
22370     out->maxDrawIndirectCount = in->maxDrawIndirectCount;
22371     out->maxSamplerLodBias = in->maxSamplerLodBias;
22372     out->maxSamplerAnisotropy = in->maxSamplerAnisotropy;
22373     out->maxViewports = in->maxViewports;
22374     memcpy(out->maxViewportDimensions, in->maxViewportDimensions, 2 * sizeof(uint32_t));
22375     memcpy(out->viewportBoundsRange, in->viewportBoundsRange, 2 * sizeof(float));
22376     out->viewportSubPixelBits = in->viewportSubPixelBits;
22377     out->minMemoryMapAlignment = in->minMemoryMapAlignment;
22378     out->minTexelBufferOffsetAlignment = in->minTexelBufferOffsetAlignment;
22379     out->minUniformBufferOffsetAlignment = in->minUniformBufferOffsetAlignment;
22380     out->minStorageBufferOffsetAlignment = in->minStorageBufferOffsetAlignment;
22381     out->minTexelOffset = in->minTexelOffset;
22382     out->maxTexelOffset = in->maxTexelOffset;
22383     out->minTexelGatherOffset = in->minTexelGatherOffset;
22384     out->maxTexelGatherOffset = in->maxTexelGatherOffset;
22385     out->minInterpolationOffset = in->minInterpolationOffset;
22386     out->maxInterpolationOffset = in->maxInterpolationOffset;
22387     out->subPixelInterpolationOffsetBits = in->subPixelInterpolationOffsetBits;
22388     out->maxFramebufferWidth = in->maxFramebufferWidth;
22389     out->maxFramebufferHeight = in->maxFramebufferHeight;
22390     out->maxFramebufferLayers = in->maxFramebufferLayers;
22391     out->framebufferColorSampleCounts = in->framebufferColorSampleCounts;
22392     out->framebufferDepthSampleCounts = in->framebufferDepthSampleCounts;
22393     out->framebufferStencilSampleCounts = in->framebufferStencilSampleCounts;
22394     out->framebufferNoAttachmentsSampleCounts = in->framebufferNoAttachmentsSampleCounts;
22395     out->maxColorAttachments = in->maxColorAttachments;
22396     out->sampledImageColorSampleCounts = in->sampledImageColorSampleCounts;
22397     out->sampledImageIntegerSampleCounts = in->sampledImageIntegerSampleCounts;
22398     out->sampledImageDepthSampleCounts = in->sampledImageDepthSampleCounts;
22399     out->sampledImageStencilSampleCounts = in->sampledImageStencilSampleCounts;
22400     out->storageImageSampleCounts = in->storageImageSampleCounts;
22401     out->maxSampleMaskWords = in->maxSampleMaskWords;
22402     out->timestampComputeAndGraphics = in->timestampComputeAndGraphics;
22403     out->timestampPeriod = in->timestampPeriod;
22404     out->maxClipDistances = in->maxClipDistances;
22405     out->maxCullDistances = in->maxCullDistances;
22406     out->maxCombinedClipAndCullDistances = in->maxCombinedClipAndCullDistances;
22407     out->discreteQueuePriorities = in->discreteQueuePriorities;
22408     memcpy(out->pointSizeRange, in->pointSizeRange, 2 * sizeof(float));
22409     memcpy(out->lineWidthRange, in->lineWidthRange, 2 * sizeof(float));
22410     out->pointSizeGranularity = in->pointSizeGranularity;
22411     out->lineWidthGranularity = in->lineWidthGranularity;
22412     out->strictLines = in->strictLines;
22413     out->standardSampleLocations = in->standardSampleLocations;
22414     out->optimalBufferCopyOffsetAlignment = in->optimalBufferCopyOffsetAlignment;
22415     out->optimalBufferCopyRowPitchAlignment = in->optimalBufferCopyRowPitchAlignment;
22416     out->nonCoherentAtomSize = in->nonCoherentAtomSize;
22417 }
22418
22419 static inline void convert_VkPhysicalDeviceProperties_host_to_win32(const VkPhysicalDeviceProperties *in, VkPhysicalDeviceProperties32 *out)
22420 {
22421     if (!in) return;
22422
22423     out->apiVersion = in->apiVersion;
22424     out->driverVersion = in->driverVersion;
22425     out->vendorID = in->vendorID;
22426     out->deviceID = in->deviceID;
22427     out->deviceType = in->deviceType;
22428     memcpy(out->deviceName, in->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
22429     memcpy(out->pipelineCacheUUID, in->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
22430     convert_VkPhysicalDeviceLimits_host_to_win32(&in->limits, &out->limits);
22431     out->sparseProperties = in->sparseProperties;
22432 }
22433
22434 static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceProperties232 *in, VkPhysicalDeviceProperties2 *out)
22435 {
22436     const VkBaseInStructure32 *in_header;
22437     VkBaseOutStructure *out_header = (void *)out;
22438
22439     if (!in) return;
22440
22441     out->sType = in->sType;
22442     out->pNext = NULL;
22443
22444     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
22445     {
22446         switch (in_header->sType)
22447         {
22448         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
22449         {
22450             VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22451             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV;
22452             out_ext->pNext = NULL;
22453             out_header->pNext = (void *)out_ext;
22454             out_header = (void *)out_ext;
22455             break;
22456         }
22457         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
22458         {
22459             VkPhysicalDeviceMultiDrawPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22460             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
22461             out_ext->pNext = NULL;
22462             out_header->pNext = (void *)out_ext;
22463             out_header = (void *)out_ext;
22464             break;
22465         }
22466         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
22467         {
22468             VkPhysicalDevicePushDescriptorPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22469             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
22470             out_ext->pNext = NULL;
22471             out_header->pNext = (void *)out_ext;
22472             out_header = (void *)out_ext;
22473             break;
22474         }
22475         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
22476         {
22477             VkPhysicalDeviceDriverProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22478             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
22479             out_ext->pNext = NULL;
22480             out_header->pNext = (void *)out_ext;
22481             out_header = (void *)out_ext;
22482             break;
22483         }
22484         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
22485         {
22486             VkPhysicalDeviceIDProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22487             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
22488             out_ext->pNext = NULL;
22489             out_header->pNext = (void *)out_ext;
22490             out_header = (void *)out_ext;
22491             break;
22492         }
22493         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
22494         {
22495             VkPhysicalDeviceMultiviewProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22496             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
22497             out_ext->pNext = NULL;
22498             out_header->pNext = (void *)out_ext;
22499             out_header = (void *)out_ext;
22500             break;
22501         }
22502         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
22503         {
22504             VkPhysicalDeviceDiscardRectanglePropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22505             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
22506             out_ext->pNext = NULL;
22507             out_header->pNext = (void *)out_ext;
22508             out_header = (void *)out_ext;
22509             break;
22510         }
22511         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
22512         {
22513             VkPhysicalDeviceSubgroupProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22514             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
22515             out_ext->pNext = NULL;
22516             out_header->pNext = (void *)out_ext;
22517             out_header = (void *)out_ext;
22518             break;
22519         }
22520         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
22521         {
22522             VkPhysicalDevicePointClippingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22523             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
22524             out_ext->pNext = NULL;
22525             out_header->pNext = (void *)out_ext;
22526             out_header = (void *)out_ext;
22527             break;
22528         }
22529         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
22530         {
22531             VkPhysicalDeviceProtectedMemoryProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22532             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
22533             out_ext->pNext = NULL;
22534             out_header->pNext = (void *)out_ext;
22535             out_header = (void *)out_ext;
22536             break;
22537         }
22538         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
22539         {
22540             VkPhysicalDeviceSamplerFilterMinmaxProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22541             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
22542             out_ext->pNext = NULL;
22543             out_header->pNext = (void *)out_ext;
22544             out_header = (void *)out_ext;
22545             break;
22546         }
22547         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
22548         {
22549             VkPhysicalDeviceSampleLocationsPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22550             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
22551             out_ext->pNext = NULL;
22552             out_header->pNext = (void *)out_ext;
22553             out_header = (void *)out_ext;
22554             break;
22555         }
22556         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
22557         {
22558             VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22559             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
22560             out_ext->pNext = NULL;
22561             out_header->pNext = (void *)out_ext;
22562             out_header = (void *)out_ext;
22563             break;
22564         }
22565         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
22566         {
22567             VkPhysicalDeviceInlineUniformBlockProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22568             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
22569             out_ext->pNext = NULL;
22570             out_header->pNext = (void *)out_ext;
22571             out_header = (void *)out_ext;
22572             break;
22573         }
22574         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
22575         {
22576             VkPhysicalDeviceMaintenance3Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22577             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
22578             out_ext->pNext = NULL;
22579             out_header->pNext = (void *)out_ext;
22580             out_header = (void *)out_ext;
22581             break;
22582         }
22583         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
22584         {
22585             VkPhysicalDeviceMaintenance4Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22586             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
22587             out_ext->pNext = NULL;
22588             out_header->pNext = (void *)out_ext;
22589             out_header = (void *)out_ext;
22590             break;
22591         }
22592         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
22593         {
22594             VkPhysicalDeviceFloatControlsProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22595             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
22596             out_ext->pNext = NULL;
22597             out_header->pNext = (void *)out_ext;
22598             out_header = (void *)out_ext;
22599             break;
22600         }
22601         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
22602         {
22603             VkPhysicalDeviceExternalMemoryHostPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22604             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
22605             out_ext->pNext = NULL;
22606             out_header->pNext = (void *)out_ext;
22607             out_header = (void *)out_ext;
22608             break;
22609         }
22610         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
22611         {
22612             VkPhysicalDeviceConservativeRasterizationPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22613             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
22614             out_ext->pNext = NULL;
22615             out_header->pNext = (void *)out_ext;
22616             out_header = (void *)out_ext;
22617             break;
22618         }
22619         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
22620         {
22621             VkPhysicalDeviceShaderCorePropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22622             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;
22623             out_ext->pNext = NULL;
22624             out_header->pNext = (void *)out_ext;
22625             out_header = (void *)out_ext;
22626             break;
22627         }
22628         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
22629         {
22630             VkPhysicalDeviceShaderCoreProperties2AMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22631             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
22632             out_ext->pNext = NULL;
22633             out_header->pNext = (void *)out_ext;
22634             out_header = (void *)out_ext;
22635             break;
22636         }
22637         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
22638         {
22639             VkPhysicalDeviceDescriptorIndexingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22640             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
22641             out_ext->pNext = NULL;
22642             out_header->pNext = (void *)out_ext;
22643             out_header = (void *)out_ext;
22644             break;
22645         }
22646         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
22647         {
22648             VkPhysicalDeviceTimelineSemaphoreProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22649             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
22650             out_ext->pNext = NULL;
22651             out_header->pNext = (void *)out_ext;
22652             out_header = (void *)out_ext;
22653             break;
22654         }
22655         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
22656         {
22657             VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22658             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
22659             out_ext->pNext = NULL;
22660             out_header->pNext = (void *)out_ext;
22661             out_header = (void *)out_ext;
22662             break;
22663         }
22664         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
22665         {
22666             VkPhysicalDevicePCIBusInfoPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22667             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
22668             out_ext->pNext = NULL;
22669             out_header->pNext = (void *)out_ext;
22670             out_header = (void *)out_ext;
22671             break;
22672         }
22673         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
22674         {
22675             VkPhysicalDeviceDepthStencilResolveProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22676             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
22677             out_ext->pNext = NULL;
22678             out_header->pNext = (void *)out_ext;
22679             out_header = (void *)out_ext;
22680             break;
22681         }
22682         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
22683         {
22684             VkPhysicalDeviceTransformFeedbackPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22685             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
22686             out_ext->pNext = NULL;
22687             out_header->pNext = (void *)out_ext;
22688             out_header = (void *)out_ext;
22689             break;
22690         }
22691         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
22692         {
22693             VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22694             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
22695             out_ext->pNext = NULL;
22696             out_header->pNext = (void *)out_ext;
22697             out_header = (void *)out_ext;
22698             break;
22699         }
22700         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
22701         {
22702             VkPhysicalDeviceMemoryDecompressionPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22703             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV;
22704             out_ext->pNext = NULL;
22705             out_header->pNext = (void *)out_ext;
22706             out_header = (void *)out_ext;
22707             break;
22708         }
22709         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
22710         {
22711             VkPhysicalDeviceShadingRateImagePropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22712             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV;
22713             out_ext->pNext = NULL;
22714             out_header->pNext = (void *)out_ext;
22715             out_header = (void *)out_ext;
22716             break;
22717         }
22718         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
22719         {
22720             VkPhysicalDeviceMeshShaderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22721             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV;
22722             out_ext->pNext = NULL;
22723             out_header->pNext = (void *)out_ext;
22724             out_header = (void *)out_ext;
22725             break;
22726         }
22727         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
22728         {
22729             VkPhysicalDeviceMeshShaderPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22730             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
22731             out_ext->pNext = NULL;
22732             out_header->pNext = (void *)out_ext;
22733             out_header = (void *)out_ext;
22734             break;
22735         }
22736         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
22737         {
22738             VkPhysicalDeviceAccelerationStructurePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22739             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
22740             out_ext->pNext = NULL;
22741             out_header->pNext = (void *)out_ext;
22742             out_header = (void *)out_ext;
22743             break;
22744         }
22745         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
22746         {
22747             VkPhysicalDeviceRayTracingPipelinePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22748             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
22749             out_ext->pNext = NULL;
22750             out_header->pNext = (void *)out_ext;
22751             out_header = (void *)out_ext;
22752             break;
22753         }
22754         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
22755         {
22756             VkPhysicalDeviceRayTracingPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22757             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
22758             out_ext->pNext = NULL;
22759             out_header->pNext = (void *)out_ext;
22760             out_header = (void *)out_ext;
22761             break;
22762         }
22763         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
22764         {
22765             VkPhysicalDeviceFragmentDensityMapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22766             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
22767             out_ext->pNext = NULL;
22768             out_header->pNext = (void *)out_ext;
22769             out_header = (void *)out_ext;
22770             break;
22771         }
22772         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
22773         {
22774             VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22775             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
22776             out_ext->pNext = NULL;
22777             out_header->pNext = (void *)out_ext;
22778             out_header = (void *)out_ext;
22779             break;
22780         }
22781         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
22782         {
22783             VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22784             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM;
22785             out_ext->pNext = NULL;
22786             out_header->pNext = (void *)out_ext;
22787             out_header = (void *)out_ext;
22788             break;
22789         }
22790         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
22791         {
22792             VkPhysicalDeviceCooperativeMatrixPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22793             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV;
22794             out_ext->pNext = NULL;
22795             out_header->pNext = (void *)out_ext;
22796             out_header = (void *)out_ext;
22797             break;
22798         }
22799         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
22800         {
22801             VkPhysicalDevicePerformanceQueryPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22802             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
22803             out_ext->pNext = NULL;
22804             out_header->pNext = (void *)out_ext;
22805             out_header = (void *)out_ext;
22806             break;
22807         }
22808         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
22809         {
22810             VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22811             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
22812             out_ext->pNext = NULL;
22813             out_header->pNext = (void *)out_ext;
22814             out_header = (void *)out_ext;
22815             break;
22816         }
22817         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
22818         {
22819             VkPhysicalDeviceTexelBufferAlignmentProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22820             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
22821             out_ext->pNext = NULL;
22822             out_header->pNext = (void *)out_ext;
22823             out_header = (void *)out_ext;
22824             break;
22825         }
22826         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
22827         {
22828             VkPhysicalDeviceSubgroupSizeControlProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22829             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
22830             out_ext->pNext = NULL;
22831             out_header->pNext = (void *)out_ext;
22832             out_header = (void *)out_ext;
22833             break;
22834         }
22835         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
22836         {
22837             VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22838             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI;
22839             out_ext->pNext = NULL;
22840             out_header->pNext = (void *)out_ext;
22841             out_header = (void *)out_ext;
22842             break;
22843         }
22844         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
22845         {
22846             VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22847             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI;
22848             out_ext->pNext = NULL;
22849             out_header->pNext = (void *)out_ext;
22850             out_header = (void *)out_ext;
22851             break;
22852         }
22853         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
22854         {
22855             VkPhysicalDeviceLineRasterizationPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22856             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT;
22857             out_ext->pNext = NULL;
22858             out_header->pNext = (void *)out_ext;
22859             out_header = (void *)out_ext;
22860             break;
22861         }
22862         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
22863         {
22864             VkPhysicalDeviceVulkan11Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22865             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
22866             out_ext->pNext = NULL;
22867             out_header->pNext = (void *)out_ext;
22868             out_header = (void *)out_ext;
22869             break;
22870         }
22871         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
22872         {
22873             VkPhysicalDeviceVulkan12Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22874             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
22875             out_ext->pNext = NULL;
22876             out_header->pNext = (void *)out_ext;
22877             out_header = (void *)out_ext;
22878             break;
22879         }
22880         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
22881         {
22882             VkPhysicalDeviceVulkan13Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22883             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
22884             out_ext->pNext = NULL;
22885             out_header->pNext = (void *)out_ext;
22886             out_header = (void *)out_ext;
22887             break;
22888         }
22889         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
22890         {
22891             VkPhysicalDeviceCustomBorderColorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22892             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
22893             out_ext->pNext = NULL;
22894             out_header->pNext = (void *)out_ext;
22895             out_header = (void *)out_ext;
22896             break;
22897         }
22898         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
22899         {
22900             VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22901             const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 *)in_header;
22902             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
22903             out_ext->pNext = NULL;
22904             out_ext->dynamicPrimitiveTopologyUnrestricted = in_ext->dynamicPrimitiveTopologyUnrestricted;
22905             out_header->pNext = (void *)out_ext;
22906             out_header = (void *)out_ext;
22907             break;
22908         }
22909         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
22910         {
22911             VkPhysicalDeviceRobustness2PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22912             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT;
22913             out_ext->pNext = NULL;
22914             out_header->pNext = (void *)out_ext;
22915             out_header = (void *)out_ext;
22916             break;
22917         }
22918         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
22919         {
22920             VkPhysicalDeviceFragmentShadingRatePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22921             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
22922             out_ext->pNext = NULL;
22923             out_header->pNext = (void *)out_ext;
22924             out_header = (void *)out_ext;
22925             break;
22926         }
22927         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
22928         {
22929             VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22930             const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 *)in_header;
22931             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV;
22932             out_ext->pNext = NULL;
22933             out_ext->maxFragmentShadingRateInvocationCount = in_ext->maxFragmentShadingRateInvocationCount;
22934             out_header->pNext = (void *)out_ext;
22935             out_header = (void *)out_ext;
22936             break;
22937         }
22938         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
22939         {
22940             VkPhysicalDeviceProvokingVertexPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22941             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
22942             out_ext->pNext = NULL;
22943             out_header->pNext = (void *)out_ext;
22944             out_header = (void *)out_ext;
22945             break;
22946         }
22947         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
22948         {
22949             VkPhysicalDeviceDescriptorBufferPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22950             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT;
22951             out_ext->pNext = NULL;
22952             out_header->pNext = (void *)out_ext;
22953             out_header = (void *)out_ext;
22954             break;
22955         }
22956         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
22957         {
22958             VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22959             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT;
22960             out_ext->pNext = NULL;
22961             out_header->pNext = (void *)out_ext;
22962             out_header = (void *)out_ext;
22963             break;
22964         }
22965         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
22966         {
22967             VkPhysicalDeviceShaderIntegerDotProductProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22968             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
22969             out_ext->pNext = NULL;
22970             out_header->pNext = (void *)out_ext;
22971             out_header = (void *)out_ext;
22972             break;
22973         }
22974         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
22975         {
22976             VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22977             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
22978             out_ext->pNext = NULL;
22979             out_header->pNext = (void *)out_ext;
22980             out_header = (void *)out_ext;
22981             break;
22982         }
22983         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
22984         {
22985             VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22986             const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *)in_header;
22987             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
22988             out_ext->pNext = NULL;
22989             out_ext->graphicsPipelineLibraryFastLinking = in_ext->graphicsPipelineLibraryFastLinking;
22990             out_ext->graphicsPipelineLibraryIndependentInterpolationDecoration = in_ext->graphicsPipelineLibraryIndependentInterpolationDecoration;
22991             out_header->pNext = (void *)out_ext;
22992             out_header = (void *)out_ext;
22993             break;
22994         }
22995         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
22996         {
22997             VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22998             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
22999             out_ext->pNext = NULL;
23000             out_header->pNext = (void *)out_ext;
23001             out_header = (void *)out_ext;
23002             break;
23003         }
23004         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
23005         {
23006             VkPhysicalDeviceOpacityMicromapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23007             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
23008             out_ext->pNext = NULL;
23009             out_header->pNext = (void *)out_ext;
23010             out_header = (void *)out_ext;
23011             break;
23012         }
23013         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
23014         {
23015             VkPhysicalDevicePipelineRobustnessPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23016             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT;
23017             out_ext->pNext = NULL;
23018             out_header->pNext = (void *)out_ext;
23019             out_header = (void *)out_ext;
23020             break;
23021         }
23022         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
23023         {
23024             VkPhysicalDeviceImageProcessingPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23025             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM;
23026             out_ext->pNext = NULL;
23027             out_header->pNext = (void *)out_ext;
23028             out_header = (void *)out_ext;
23029             break;
23030         }
23031         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
23032         {
23033             VkPhysicalDeviceOpticalFlowPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23034             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV;
23035             out_ext->pNext = NULL;
23036             out_header->pNext = (void *)out_ext;
23037             out_header = (void *)out_ext;
23038             break;
23039         }
23040         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
23041         {
23042             VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23043             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM;
23044             out_ext->pNext = NULL;
23045             out_header->pNext = (void *)out_ext;
23046             out_header = (void *)out_ext;
23047             break;
23048         }
23049         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
23050         {
23051             VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23052             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV;
23053             out_ext->pNext = NULL;
23054             out_header->pNext = (void *)out_ext;
23055             out_header = (void *)out_ext;
23056             break;
23057         }
23058         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
23059         {
23060             VkPhysicalDeviceShaderCorePropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23061             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM;
23062             out_ext->pNext = NULL;
23063             out_header->pNext = (void *)out_ext;
23064             out_header = (void *)out_ext;
23065             break;
23066         }
23067         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
23068         {
23069             VkPhysicalDeviceShaderObjectPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23070             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT;
23071             out_ext->pNext = NULL;
23072             out_header->pNext = (void *)out_ext;
23073             out_header = (void *)out_ext;
23074             break;
23075         }
23076         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
23077         {
23078             VkPhysicalDeviceShaderTileImagePropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23079             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT;
23080             out_ext->pNext = NULL;
23081             out_header->pNext = (void *)out_ext;
23082             out_header = (void *)out_ext;
23083             break;
23084         }
23085         default:
23086             FIXME("Unhandled sType %u.\n", in_header->sType);
23087             break;
23088         }
23089     }
23090 }
23091
23092 static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDeviceProperties2 *in, VkPhysicalDeviceProperties232 *out)
23093 {
23094     const VkBaseInStructure *in_header;
23095     VkBaseOutStructure32 *out_header = (void *)out;
23096
23097     if (!in) return;
23098
23099     convert_VkPhysicalDeviceProperties_host_to_win32(&in->properties, &out->properties);
23100
23101     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
23102     {
23103         switch (in_header->sType)
23104         {
23105         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
23106         {
23107             VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV);
23108             const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *)in_header;
23109             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV;
23110             out_ext->maxGraphicsShaderGroupCount = in_ext->maxGraphicsShaderGroupCount;
23111             out_ext->maxIndirectSequenceCount = in_ext->maxIndirectSequenceCount;
23112             out_ext->maxIndirectCommandsTokenCount = in_ext->maxIndirectCommandsTokenCount;
23113             out_ext->maxIndirectCommandsStreamCount = in_ext->maxIndirectCommandsStreamCount;
23114             out_ext->maxIndirectCommandsTokenOffset = in_ext->maxIndirectCommandsTokenOffset;
23115             out_ext->maxIndirectCommandsStreamStride = in_ext->maxIndirectCommandsStreamStride;
23116             out_ext->minSequencesCountBufferOffsetAlignment = in_ext->minSequencesCountBufferOffsetAlignment;
23117             out_ext->minSequencesIndexBufferOffsetAlignment = in_ext->minSequencesIndexBufferOffsetAlignment;
23118             out_ext->minIndirectCommandsBufferOffsetAlignment = in_ext->minIndirectCommandsBufferOffsetAlignment;
23119             out_header = (void *)out_ext;
23120             break;
23121         }
23122         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
23123         {
23124             VkPhysicalDeviceMultiDrawPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT);
23125             const VkPhysicalDeviceMultiDrawPropertiesEXT *in_ext = (const VkPhysicalDeviceMultiDrawPropertiesEXT *)in_header;
23126             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
23127             out_ext->maxMultiDrawCount = in_ext->maxMultiDrawCount;
23128             out_header = (void *)out_ext;
23129             break;
23130         }
23131         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
23132         {
23133             VkPhysicalDevicePushDescriptorPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR);
23134             const VkPhysicalDevicePushDescriptorPropertiesKHR *in_ext = (const VkPhysicalDevicePushDescriptorPropertiesKHR *)in_header;
23135             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
23136             out_ext->maxPushDescriptors = in_ext->maxPushDescriptors;
23137             out_header = (void *)out_ext;
23138             break;
23139         }
23140         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
23141         {
23142             VkPhysicalDeviceDriverProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
23143             const VkPhysicalDeviceDriverProperties *in_ext = (const VkPhysicalDeviceDriverProperties *)in_header;
23144             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
23145             out_ext->driverID = in_ext->driverID;
23146             memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
23147             memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
23148             out_ext->conformanceVersion = in_ext->conformanceVersion;
23149             out_header = (void *)out_ext;
23150             break;
23151         }
23152         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
23153         {
23154             VkPhysicalDeviceIDProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
23155             const VkPhysicalDeviceIDProperties *in_ext = (const VkPhysicalDeviceIDProperties *)in_header;
23156             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
23157             memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
23158             memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
23159             memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
23160             out_ext->deviceNodeMask = in_ext->deviceNodeMask;
23161             out_ext->deviceLUIDValid = in_ext->deviceLUIDValid;
23162             out_header = (void *)out_ext;
23163             break;
23164         }
23165         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
23166         {
23167             VkPhysicalDeviceMultiviewProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
23168             const VkPhysicalDeviceMultiviewProperties *in_ext = (const VkPhysicalDeviceMultiviewProperties *)in_header;
23169             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
23170             out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount;
23171             out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex;
23172             out_header = (void *)out_ext;
23173             break;
23174         }
23175         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
23176         {
23177             VkPhysicalDeviceDiscardRectanglePropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT);
23178             const VkPhysicalDeviceDiscardRectanglePropertiesEXT *in_ext = (const VkPhysicalDeviceDiscardRectanglePropertiesEXT *)in_header;
23179             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
23180             out_ext->maxDiscardRectangles = in_ext->maxDiscardRectangles;
23181             out_header = (void *)out_ext;
23182             break;
23183         }
23184         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
23185         {
23186             VkPhysicalDeviceSubgroupProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
23187             const VkPhysicalDeviceSubgroupProperties *in_ext = (const VkPhysicalDeviceSubgroupProperties *)in_header;
23188             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
23189             out_ext->subgroupSize = in_ext->subgroupSize;
23190             out_ext->supportedStages = in_ext->supportedStages;
23191             out_ext->supportedOperations = in_ext->supportedOperations;
23192             out_ext->quadOperationsInAllStages = in_ext->quadOperationsInAllStages;
23193             out_header = (void *)out_ext;
23194             break;
23195         }
23196         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
23197         {
23198             VkPhysicalDevicePointClippingProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
23199             const VkPhysicalDevicePointClippingProperties *in_ext = (const VkPhysicalDevicePointClippingProperties *)in_header;
23200             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
23201             out_ext->pointClippingBehavior = in_ext->pointClippingBehavior;
23202             out_header = (void *)out_ext;
23203             break;
23204         }
23205         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
23206         {
23207             VkPhysicalDeviceProtectedMemoryProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
23208             const VkPhysicalDeviceProtectedMemoryProperties *in_ext = (const VkPhysicalDeviceProtectedMemoryProperties *)in_header;
23209             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
23210             out_ext->protectedNoFault = in_ext->protectedNoFault;
23211             out_header = (void *)out_ext;
23212             break;
23213         }
23214         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
23215         {
23216             VkPhysicalDeviceSamplerFilterMinmaxProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
23217             const VkPhysicalDeviceSamplerFilterMinmaxProperties *in_ext = (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)in_header;
23218             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
23219             out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats;
23220             out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping;
23221             out_header = (void *)out_ext;
23222             break;
23223         }
23224         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
23225         {
23226             VkPhysicalDeviceSampleLocationsPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT);
23227             const VkPhysicalDeviceSampleLocationsPropertiesEXT *in_ext = (const VkPhysicalDeviceSampleLocationsPropertiesEXT *)in_header;
23228             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
23229             out_ext->sampleLocationSampleCounts = in_ext->sampleLocationSampleCounts;
23230             out_ext->maxSampleLocationGridSize = in_ext->maxSampleLocationGridSize;
23231             memcpy(out_ext->sampleLocationCoordinateRange, in_ext->sampleLocationCoordinateRange, 2 * sizeof(float));
23232             out_ext->sampleLocationSubPixelBits = in_ext->sampleLocationSubPixelBits;
23233             out_ext->variableSampleLocations = in_ext->variableSampleLocations;
23234             out_header = (void *)out_ext;
23235             break;
23236         }
23237         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
23238         {
23239             VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT);
23240             const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *)in_header;
23241             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
23242             out_ext->advancedBlendMaxColorAttachments = in_ext->advancedBlendMaxColorAttachments;
23243             out_ext->advancedBlendIndependentBlend = in_ext->advancedBlendIndependentBlend;
23244             out_ext->advancedBlendNonPremultipliedSrcColor = in_ext->advancedBlendNonPremultipliedSrcColor;
23245             out_ext->advancedBlendNonPremultipliedDstColor = in_ext->advancedBlendNonPremultipliedDstColor;
23246             out_ext->advancedBlendCorrelatedOverlap = in_ext->advancedBlendCorrelatedOverlap;
23247             out_ext->advancedBlendAllOperations = in_ext->advancedBlendAllOperations;
23248             out_header = (void *)out_ext;
23249             break;
23250         }
23251         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
23252         {
23253             VkPhysicalDeviceInlineUniformBlockProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES);
23254             const VkPhysicalDeviceInlineUniformBlockProperties *in_ext = (const VkPhysicalDeviceInlineUniformBlockProperties *)in_header;
23255             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
23256             out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize;
23257             out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks;
23258             out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
23259             out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks;
23260             out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
23261             out_header = (void *)out_ext;
23262             break;
23263         }
23264         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
23265         {
23266             VkPhysicalDeviceMaintenance3Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
23267             const VkPhysicalDeviceMaintenance3Properties *in_ext = (const VkPhysicalDeviceMaintenance3Properties *)in_header;
23268             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
23269             out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors;
23270             out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize;
23271             out_header = (void *)out_ext;
23272             break;
23273         }
23274         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
23275         {
23276             VkPhysicalDeviceMaintenance4Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES);
23277             const VkPhysicalDeviceMaintenance4Properties *in_ext = (const VkPhysicalDeviceMaintenance4Properties *)in_header;
23278             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
23279             out_ext->maxBufferSize = in_ext->maxBufferSize;
23280             out_header = (void *)out_ext;
23281             break;
23282         }
23283         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
23284         {
23285             VkPhysicalDeviceFloatControlsProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
23286             const VkPhysicalDeviceFloatControlsProperties *in_ext = (const VkPhysicalDeviceFloatControlsProperties *)in_header;
23287             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
23288             out_ext->denormBehaviorIndependence = in_ext->denormBehaviorIndependence;
23289             out_ext->roundingModeIndependence = in_ext->roundingModeIndependence;
23290             out_ext->shaderSignedZeroInfNanPreserveFloat16 = in_ext->shaderSignedZeroInfNanPreserveFloat16;
23291             out_ext->shaderSignedZeroInfNanPreserveFloat32 = in_ext->shaderSignedZeroInfNanPreserveFloat32;
23292             out_ext->shaderSignedZeroInfNanPreserveFloat64 = in_ext->shaderSignedZeroInfNanPreserveFloat64;
23293             out_ext->shaderDenormPreserveFloat16 = in_ext->shaderDenormPreserveFloat16;
23294             out_ext->shaderDenormPreserveFloat32 = in_ext->shaderDenormPreserveFloat32;
23295             out_ext->shaderDenormPreserveFloat64 = in_ext->shaderDenormPreserveFloat64;
23296             out_ext->shaderDenormFlushToZeroFloat16 = in_ext->shaderDenormFlushToZeroFloat16;
23297             out_ext->shaderDenormFlushToZeroFloat32 = in_ext->shaderDenormFlushToZeroFloat32;
23298             out_ext->shaderDenormFlushToZeroFloat64 = in_ext->shaderDenormFlushToZeroFloat64;
23299             out_ext->shaderRoundingModeRTEFloat16 = in_ext->shaderRoundingModeRTEFloat16;
23300             out_ext->shaderRoundingModeRTEFloat32 = in_ext->shaderRoundingModeRTEFloat32;
23301             out_ext->shaderRoundingModeRTEFloat64 = in_ext->shaderRoundingModeRTEFloat64;
23302             out_ext->shaderRoundingModeRTZFloat16 = in_ext->shaderRoundingModeRTZFloat16;
23303             out_ext->shaderRoundingModeRTZFloat32 = in_ext->shaderRoundingModeRTZFloat32;
23304             out_ext->shaderRoundingModeRTZFloat64 = in_ext->shaderRoundingModeRTZFloat64;
23305             out_header = (void *)out_ext;
23306             break;
23307         }
23308         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
23309         {
23310             VkPhysicalDeviceExternalMemoryHostPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT);
23311             const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *in_ext = (const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *)in_header;
23312             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
23313             out_ext->minImportedHostPointerAlignment = in_ext->minImportedHostPointerAlignment;
23314             out_header = (void *)out_ext;
23315             break;
23316         }
23317         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
23318         {
23319             VkPhysicalDeviceConservativeRasterizationPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT);
23320             const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *in_ext = (const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)in_header;
23321             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
23322             out_ext->primitiveOverestimationSize = in_ext->primitiveOverestimationSize;
23323             out_ext->maxExtraPrimitiveOverestimationSize = in_ext->maxExtraPrimitiveOverestimationSize;
23324             out_ext->extraPrimitiveOverestimationSizeGranularity = in_ext->extraPrimitiveOverestimationSizeGranularity;
23325             out_ext->primitiveUnderestimation = in_ext->primitiveUnderestimation;
23326             out_ext->conservativePointAndLineRasterization = in_ext->conservativePointAndLineRasterization;
23327             out_ext->degenerateTrianglesRasterized = in_ext->degenerateTrianglesRasterized;
23328             out_ext->degenerateLinesRasterized = in_ext->degenerateLinesRasterized;
23329             out_ext->fullyCoveredFragmentShaderInputVariable = in_ext->fullyCoveredFragmentShaderInputVariable;
23330             out_ext->conservativeRasterizationPostDepthCoverage = in_ext->conservativeRasterizationPostDepthCoverage;
23331             out_header = (void *)out_ext;
23332             break;
23333         }
23334         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
23335         {
23336             VkPhysicalDeviceShaderCorePropertiesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD);
23337             const VkPhysicalDeviceShaderCorePropertiesAMD *in_ext = (const VkPhysicalDeviceShaderCorePropertiesAMD *)in_header;
23338             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;
23339             out_ext->shaderEngineCount = in_ext->shaderEngineCount;
23340             out_ext->shaderArraysPerEngineCount = in_ext->shaderArraysPerEngineCount;
23341             out_ext->computeUnitsPerShaderArray = in_ext->computeUnitsPerShaderArray;
23342             out_ext->simdPerComputeUnit = in_ext->simdPerComputeUnit;
23343             out_ext->wavefrontsPerSimd = in_ext->wavefrontsPerSimd;
23344             out_ext->wavefrontSize = in_ext->wavefrontSize;
23345             out_ext->sgprsPerSimd = in_ext->sgprsPerSimd;
23346             out_ext->minSgprAllocation = in_ext->minSgprAllocation;
23347             out_ext->maxSgprAllocation = in_ext->maxSgprAllocation;
23348             out_ext->sgprAllocationGranularity = in_ext->sgprAllocationGranularity;
23349             out_ext->vgprsPerSimd = in_ext->vgprsPerSimd;
23350             out_ext->minVgprAllocation = in_ext->minVgprAllocation;
23351             out_ext->maxVgprAllocation = in_ext->maxVgprAllocation;
23352             out_ext->vgprAllocationGranularity = in_ext->vgprAllocationGranularity;
23353             out_header = (void *)out_ext;
23354             break;
23355         }
23356         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
23357         {
23358             VkPhysicalDeviceShaderCoreProperties2AMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD);
23359             const VkPhysicalDeviceShaderCoreProperties2AMD *in_ext = (const VkPhysicalDeviceShaderCoreProperties2AMD *)in_header;
23360             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
23361             out_ext->shaderCoreFeatures = in_ext->shaderCoreFeatures;
23362             out_ext->activeComputeUnitCount = in_ext->activeComputeUnitCount;
23363             out_header = (void *)out_ext;
23364             break;
23365         }
23366         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
23367         {
23368             VkPhysicalDeviceDescriptorIndexingProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
23369             const VkPhysicalDeviceDescriptorIndexingProperties *in_ext = (const VkPhysicalDeviceDescriptorIndexingProperties *)in_header;
23370             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
23371             out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools;
23372             out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative;
23373             out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative;
23374             out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative;
23375             out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative;
23376             out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative;
23377             out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind;
23378             out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod;
23379             out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers;
23380             out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
23381             out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
23382             out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages;
23383             out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages;
23384             out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments;
23385             out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources;
23386             out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers;
23387             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers;
23388             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
23389             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers;
23390             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
23391             out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages;
23392             out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages;
23393             out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments;
23394             out_header = (void *)out_ext;
23395             break;
23396         }
23397         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
23398         {
23399             VkPhysicalDeviceTimelineSemaphoreProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
23400             const VkPhysicalDeviceTimelineSemaphoreProperties *in_ext = (const VkPhysicalDeviceTimelineSemaphoreProperties *)in_header;
23401             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
23402             out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference;
23403             out_header = (void *)out_ext;
23404             break;
23405         }
23406         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
23407         {
23408             VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT);
23409             const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)in_header;
23410             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
23411             out_ext->maxVertexAttribDivisor = in_ext->maxVertexAttribDivisor;
23412             out_header = (void *)out_ext;
23413             break;
23414         }
23415         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
23416         {
23417             VkPhysicalDevicePCIBusInfoPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT);
23418             const VkPhysicalDevicePCIBusInfoPropertiesEXT *in_ext = (const VkPhysicalDevicePCIBusInfoPropertiesEXT *)in_header;
23419             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
23420             out_ext->pciDomain = in_ext->pciDomain;
23421             out_ext->pciBus = in_ext->pciBus;
23422             out_ext->pciDevice = in_ext->pciDevice;
23423             out_ext->pciFunction = in_ext->pciFunction;
23424             out_header = (void *)out_ext;
23425             break;
23426         }
23427         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
23428         {
23429             VkPhysicalDeviceDepthStencilResolveProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
23430             const VkPhysicalDeviceDepthStencilResolveProperties *in_ext = (const VkPhysicalDeviceDepthStencilResolveProperties *)in_header;
23431             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
23432             out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes;
23433             out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes;
23434             out_ext->independentResolveNone = in_ext->independentResolveNone;
23435             out_ext->independentResolve = in_ext->independentResolve;
23436             out_header = (void *)out_ext;
23437             break;
23438         }
23439         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
23440         {
23441             VkPhysicalDeviceTransformFeedbackPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
23442             const VkPhysicalDeviceTransformFeedbackPropertiesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)in_header;
23443             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
23444             out_ext->maxTransformFeedbackStreams = in_ext->maxTransformFeedbackStreams;
23445             out_ext->maxTransformFeedbackBuffers = in_ext->maxTransformFeedbackBuffers;
23446             out_ext->maxTransformFeedbackBufferSize = in_ext->maxTransformFeedbackBufferSize;
23447             out_ext->maxTransformFeedbackStreamDataSize = in_ext->maxTransformFeedbackStreamDataSize;
23448             out_ext->maxTransformFeedbackBufferDataSize = in_ext->maxTransformFeedbackBufferDataSize;
23449             out_ext->maxTransformFeedbackBufferDataStride = in_ext->maxTransformFeedbackBufferDataStride;
23450             out_ext->transformFeedbackQueries = in_ext->transformFeedbackQueries;
23451             out_ext->transformFeedbackStreamsLinesTriangles = in_ext->transformFeedbackStreamsLinesTriangles;
23452             out_ext->transformFeedbackRasterizationStreamSelect = in_ext->transformFeedbackRasterizationStreamSelect;
23453             out_ext->transformFeedbackDraw = in_ext->transformFeedbackDraw;
23454             out_header = (void *)out_ext;
23455             break;
23456         }
23457         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
23458         {
23459             VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV);
23460             const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *)in_header;
23461             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
23462             out_ext->supportedQueues = in_ext->supportedQueues;
23463             out_header = (void *)out_ext;
23464             break;
23465         }
23466         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
23467         {
23468             VkPhysicalDeviceMemoryDecompressionPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV);
23469             const VkPhysicalDeviceMemoryDecompressionPropertiesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionPropertiesNV *)in_header;
23470             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV;
23471             out_ext->decompressionMethods = in_ext->decompressionMethods;
23472             out_ext->maxDecompressionIndirectCount = in_ext->maxDecompressionIndirectCount;
23473             out_header = (void *)out_ext;
23474             break;
23475         }
23476         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
23477         {
23478             VkPhysicalDeviceShadingRateImagePropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV);
23479             const VkPhysicalDeviceShadingRateImagePropertiesNV *in_ext = (const VkPhysicalDeviceShadingRateImagePropertiesNV *)in_header;
23480             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV;
23481             out_ext->shadingRateTexelSize = in_ext->shadingRateTexelSize;
23482             out_ext->shadingRatePaletteSize = in_ext->shadingRatePaletteSize;
23483             out_ext->shadingRateMaxCoarseSamples = in_ext->shadingRateMaxCoarseSamples;
23484             out_header = (void *)out_ext;
23485             break;
23486         }
23487         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
23488         {
23489             VkPhysicalDeviceMeshShaderPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV);
23490             const VkPhysicalDeviceMeshShaderPropertiesNV *in_ext = (const VkPhysicalDeviceMeshShaderPropertiesNV *)in_header;
23491             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV;
23492             out_ext->maxDrawMeshTasksCount = in_ext->maxDrawMeshTasksCount;
23493             out_ext->maxTaskWorkGroupInvocations = in_ext->maxTaskWorkGroupInvocations;
23494             memcpy(out_ext->maxTaskWorkGroupSize, in_ext->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
23495             out_ext->maxTaskTotalMemorySize = in_ext->maxTaskTotalMemorySize;
23496             out_ext->maxTaskOutputCount = in_ext->maxTaskOutputCount;
23497             out_ext->maxMeshWorkGroupInvocations = in_ext->maxMeshWorkGroupInvocations;
23498             memcpy(out_ext->maxMeshWorkGroupSize, in_ext->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
23499             out_ext->maxMeshTotalMemorySize = in_ext->maxMeshTotalMemorySize;
23500             out_ext->maxMeshOutputVertices = in_ext->maxMeshOutputVertices;
23501             out_ext->maxMeshOutputPrimitives = in_ext->maxMeshOutputPrimitives;
23502             out_ext->maxMeshMultiviewViewCount = in_ext->maxMeshMultiviewViewCount;
23503             out_ext->meshOutputPerVertexGranularity = in_ext->meshOutputPerVertexGranularity;
23504             out_ext->meshOutputPerPrimitiveGranularity = in_ext->meshOutputPerPrimitiveGranularity;
23505             out_header = (void *)out_ext;
23506             break;
23507         }
23508         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
23509         {
23510             VkPhysicalDeviceMeshShaderPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT);
23511             const VkPhysicalDeviceMeshShaderPropertiesEXT *in_ext = (const VkPhysicalDeviceMeshShaderPropertiesEXT *)in_header;
23512             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
23513             out_ext->maxTaskWorkGroupTotalCount = in_ext->maxTaskWorkGroupTotalCount;
23514             memcpy(out_ext->maxTaskWorkGroupCount, in_ext->maxTaskWorkGroupCount, 3 * sizeof(uint32_t));
23515             out_ext->maxTaskWorkGroupInvocations = in_ext->maxTaskWorkGroupInvocations;
23516             memcpy(out_ext->maxTaskWorkGroupSize, in_ext->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
23517             out_ext->maxTaskPayloadSize = in_ext->maxTaskPayloadSize;
23518             out_ext->maxTaskSharedMemorySize = in_ext->maxTaskSharedMemorySize;
23519             out_ext->maxTaskPayloadAndSharedMemorySize = in_ext->maxTaskPayloadAndSharedMemorySize;
23520             out_ext->maxMeshWorkGroupTotalCount = in_ext->maxMeshWorkGroupTotalCount;
23521             memcpy(out_ext->maxMeshWorkGroupCount, in_ext->maxMeshWorkGroupCount, 3 * sizeof(uint32_t));
23522             out_ext->maxMeshWorkGroupInvocations = in_ext->maxMeshWorkGroupInvocations;
23523             memcpy(out_ext->maxMeshWorkGroupSize, in_ext->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
23524             out_ext->maxMeshSharedMemorySize = in_ext->maxMeshSharedMemorySize;
23525             out_ext->maxMeshPayloadAndSharedMemorySize = in_ext->maxMeshPayloadAndSharedMemorySize;
23526             out_ext->maxMeshOutputMemorySize = in_ext->maxMeshOutputMemorySize;
23527             out_ext->maxMeshPayloadAndOutputMemorySize = in_ext->maxMeshPayloadAndOutputMemorySize;
23528             out_ext->maxMeshOutputComponents = in_ext->maxMeshOutputComponents;
23529             out_ext->maxMeshOutputVertices = in_ext->maxMeshOutputVertices;
23530             out_ext->maxMeshOutputPrimitives = in_ext->maxMeshOutputPrimitives;
23531             out_ext->maxMeshOutputLayers = in_ext->maxMeshOutputLayers;
23532             out_ext->maxMeshMultiviewViewCount = in_ext->maxMeshMultiviewViewCount;
23533             out_ext->meshOutputPerVertexGranularity = in_ext->meshOutputPerVertexGranularity;
23534             out_ext->meshOutputPerPrimitiveGranularity = in_ext->meshOutputPerPrimitiveGranularity;
23535             out_ext->maxPreferredTaskWorkGroupInvocations = in_ext->maxPreferredTaskWorkGroupInvocations;
23536             out_ext->maxPreferredMeshWorkGroupInvocations = in_ext->maxPreferredMeshWorkGroupInvocations;
23537             out_ext->prefersLocalInvocationVertexOutput = in_ext->prefersLocalInvocationVertexOutput;
23538             out_ext->prefersLocalInvocationPrimitiveOutput = in_ext->prefersLocalInvocationPrimitiveOutput;
23539             out_ext->prefersCompactVertexOutput = in_ext->prefersCompactVertexOutput;
23540             out_ext->prefersCompactPrimitiveOutput = in_ext->prefersCompactPrimitiveOutput;
23541             out_header = (void *)out_ext;
23542             break;
23543         }
23544         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
23545         {
23546             VkPhysicalDeviceAccelerationStructurePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR);
23547             const VkPhysicalDeviceAccelerationStructurePropertiesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructurePropertiesKHR *)in_header;
23548             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
23549             out_ext->maxGeometryCount = in_ext->maxGeometryCount;
23550             out_ext->maxInstanceCount = in_ext->maxInstanceCount;
23551             out_ext->maxPrimitiveCount = in_ext->maxPrimitiveCount;
23552             out_ext->maxPerStageDescriptorAccelerationStructures = in_ext->maxPerStageDescriptorAccelerationStructures;
23553             out_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures = in_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
23554             out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures;
23555             out_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures = in_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures;
23556             out_ext->minAccelerationStructureScratchOffsetAlignment = in_ext->minAccelerationStructureScratchOffsetAlignment;
23557             out_header = (void *)out_ext;
23558             break;
23559         }
23560         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
23561         {
23562             VkPhysicalDeviceRayTracingPipelinePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR);
23563             const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *)in_header;
23564             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
23565             out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize;
23566             out_ext->maxRayRecursionDepth = in_ext->maxRayRecursionDepth;
23567             out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride;
23568             out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment;
23569             out_ext->shaderGroupHandleCaptureReplaySize = in_ext->shaderGroupHandleCaptureReplaySize;
23570             out_ext->maxRayDispatchInvocationCount = in_ext->maxRayDispatchInvocationCount;
23571             out_ext->shaderGroupHandleAlignment = in_ext->shaderGroupHandleAlignment;
23572             out_ext->maxRayHitAttributeSize = in_ext->maxRayHitAttributeSize;
23573             out_header = (void *)out_ext;
23574             break;
23575         }
23576         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
23577         {
23578             VkPhysicalDeviceRayTracingPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV);
23579             const VkPhysicalDeviceRayTracingPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingPropertiesNV *)in_header;
23580             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
23581             out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize;
23582             out_ext->maxRecursionDepth = in_ext->maxRecursionDepth;
23583             out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride;
23584             out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment;
23585             out_ext->maxGeometryCount = in_ext->maxGeometryCount;
23586             out_ext->maxInstanceCount = in_ext->maxInstanceCount;
23587             out_ext->maxTriangleCount = in_ext->maxTriangleCount;
23588             out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures;
23589             out_header = (void *)out_ext;
23590             break;
23591         }
23592         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
23593         {
23594             VkPhysicalDeviceFragmentDensityMapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT);
23595             const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *)in_header;
23596             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
23597             out_ext->minFragmentDensityTexelSize = in_ext->minFragmentDensityTexelSize;
23598             out_ext->maxFragmentDensityTexelSize = in_ext->maxFragmentDensityTexelSize;
23599             out_ext->fragmentDensityInvocations = in_ext->fragmentDensityInvocations;
23600             out_header = (void *)out_ext;
23601             break;
23602         }
23603         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
23604         {
23605             VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT);
23606             const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *)in_header;
23607             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
23608             out_ext->subsampledLoads = in_ext->subsampledLoads;
23609             out_ext->subsampledCoarseReconstructionEarlyAccess = in_ext->subsampledCoarseReconstructionEarlyAccess;
23610             out_ext->maxSubsampledArrayLayers = in_ext->maxSubsampledArrayLayers;
23611             out_ext->maxDescriptorSetSubsampledSamplers = in_ext->maxDescriptorSetSubsampledSamplers;
23612             out_header = (void *)out_ext;
23613             break;
23614         }
23615         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
23616         {
23617             VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM);
23618             const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *)in_header;
23619             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM;
23620             out_ext->fragmentDensityOffsetGranularity = in_ext->fragmentDensityOffsetGranularity;
23621             out_header = (void *)out_ext;
23622             break;
23623         }
23624         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
23625         {
23626             VkPhysicalDeviceCooperativeMatrixPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV);
23627             const VkPhysicalDeviceCooperativeMatrixPropertiesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixPropertiesNV *)in_header;
23628             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV;
23629             out_ext->cooperativeMatrixSupportedStages = in_ext->cooperativeMatrixSupportedStages;
23630             out_header = (void *)out_ext;
23631             break;
23632         }
23633         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
23634         {
23635             VkPhysicalDevicePerformanceQueryPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR);
23636             const VkPhysicalDevicePerformanceQueryPropertiesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryPropertiesKHR *)in_header;
23637             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
23638             out_ext->allowCommandBufferQueryCopies = in_ext->allowCommandBufferQueryCopies;
23639             out_header = (void *)out_ext;
23640             break;
23641         }
23642         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
23643         {
23644             VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV);
23645             const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *)in_header;
23646             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
23647             out_ext->shaderSMCount = in_ext->shaderSMCount;
23648             out_ext->shaderWarpsPerSM = in_ext->shaderWarpsPerSM;
23649             out_header = (void *)out_ext;
23650             break;
23651         }
23652         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
23653         {
23654             VkPhysicalDeviceTexelBufferAlignmentProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES);
23655             const VkPhysicalDeviceTexelBufferAlignmentProperties *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentProperties *)in_header;
23656             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
23657             out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes;
23658             out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment;
23659             out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes;
23660             out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment;
23661             out_header = (void *)out_ext;
23662             break;
23663         }
23664         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
23665         {
23666             VkPhysicalDeviceSubgroupSizeControlProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES);
23667             const VkPhysicalDeviceSubgroupSizeControlProperties *in_ext = (const VkPhysicalDeviceSubgroupSizeControlProperties *)in_header;
23668             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
23669             out_ext->minSubgroupSize = in_ext->minSubgroupSize;
23670             out_ext->maxSubgroupSize = in_ext->maxSubgroupSize;
23671             out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups;
23672             out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages;
23673             out_header = (void *)out_ext;
23674             break;
23675         }
23676         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
23677         {
23678             VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI);
23679             const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *)in_header;
23680             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI;
23681             out_ext->maxSubpassShadingWorkgroupSizeAspectRatio = in_ext->maxSubpassShadingWorkgroupSizeAspectRatio;
23682             out_header = (void *)out_ext;
23683             break;
23684         }
23685         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
23686         {
23687             VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI);
23688             const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *)in_header;
23689             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI;
23690             memcpy(out_ext->maxWorkGroupCount, in_ext->maxWorkGroupCount, 3 * sizeof(uint32_t));
23691             memcpy(out_ext->maxWorkGroupSize, in_ext->maxWorkGroupSize, 3 * sizeof(uint32_t));
23692             out_ext->maxOutputClusterCount = in_ext->maxOutputClusterCount;
23693             out_ext->indirectBufferOffsetAlignment = in_ext->indirectBufferOffsetAlignment;
23694             out_header = (void *)out_ext;
23695             break;
23696         }
23697         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
23698         {
23699             VkPhysicalDeviceLineRasterizationPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT);
23700             const VkPhysicalDeviceLineRasterizationPropertiesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationPropertiesEXT *)in_header;
23701             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT;
23702             out_ext->lineSubPixelPrecisionBits = in_ext->lineSubPixelPrecisionBits;
23703             out_header = (void *)out_ext;
23704             break;
23705         }
23706         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
23707         {
23708             VkPhysicalDeviceVulkan11Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
23709             const VkPhysicalDeviceVulkan11Properties *in_ext = (const VkPhysicalDeviceVulkan11Properties *)in_header;
23710             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
23711             memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
23712             memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
23713             memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
23714             out_ext->deviceNodeMask = in_ext->deviceNodeMask;
23715             out_ext->deviceLUIDValid = in_ext->deviceLUIDValid;
23716             out_ext->subgroupSize = in_ext->subgroupSize;
23717             out_ext->subgroupSupportedStages = in_ext->subgroupSupportedStages;
23718             out_ext->subgroupSupportedOperations = in_ext->subgroupSupportedOperations;
23719             out_ext->subgroupQuadOperationsInAllStages = in_ext->subgroupQuadOperationsInAllStages;
23720             out_ext->pointClippingBehavior = in_ext->pointClippingBehavior;
23721             out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount;
23722             out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex;
23723             out_ext->protectedNoFault = in_ext->protectedNoFault;
23724             out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors;
23725             out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize;
23726             out_header = (void *)out_ext;
23727             break;
23728         }
23729         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
23730         {
23731             VkPhysicalDeviceVulkan12Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
23732             const VkPhysicalDeviceVulkan12Properties *in_ext = (const VkPhysicalDeviceVulkan12Properties *)in_header;
23733             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
23734             out_ext->driverID = in_ext->driverID;
23735             memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
23736             memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
23737             out_ext->conformanceVersion = in_ext->conformanceVersion;
23738             out_ext->denormBehaviorIndependence = in_ext->denormBehaviorIndependence;
23739             out_ext->roundingModeIndependence = in_ext->roundingModeIndependence;
23740             out_ext->shaderSignedZeroInfNanPreserveFloat16 = in_ext->shaderSignedZeroInfNanPreserveFloat16;
23741             out_ext->shaderSignedZeroInfNanPreserveFloat32 = in_ext->shaderSignedZeroInfNanPreserveFloat32;
23742             out_ext->shaderSignedZeroInfNanPreserveFloat64 = in_ext->shaderSignedZeroInfNanPreserveFloat64;
23743             out_ext->shaderDenormPreserveFloat16 = in_ext->shaderDenormPreserveFloat16;
23744             out_ext->shaderDenormPreserveFloat32 = in_ext->shaderDenormPreserveFloat32;
23745             out_ext->shaderDenormPreserveFloat64 = in_ext->shaderDenormPreserveFloat64;
23746             out_ext->shaderDenormFlushToZeroFloat16 = in_ext->shaderDenormFlushToZeroFloat16;
23747             out_ext->shaderDenormFlushToZeroFloat32 = in_ext->shaderDenormFlushToZeroFloat32;
23748             out_ext->shaderDenormFlushToZeroFloat64 = in_ext->shaderDenormFlushToZeroFloat64;
23749             out_ext->shaderRoundingModeRTEFloat16 = in_ext->shaderRoundingModeRTEFloat16;
23750             out_ext->shaderRoundingModeRTEFloat32 = in_ext->shaderRoundingModeRTEFloat32;
23751             out_ext->shaderRoundingModeRTEFloat64 = in_ext->shaderRoundingModeRTEFloat64;
23752             out_ext->shaderRoundingModeRTZFloat16 = in_ext->shaderRoundingModeRTZFloat16;
23753             out_ext->shaderRoundingModeRTZFloat32 = in_ext->shaderRoundingModeRTZFloat32;
23754             out_ext->shaderRoundingModeRTZFloat64 = in_ext->shaderRoundingModeRTZFloat64;
23755             out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools;
23756             out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative;
23757             out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative;
23758             out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative;
23759             out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative;
23760             out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative;
23761             out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind;
23762             out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod;
23763             out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers;
23764             out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
23765             out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
23766             out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages;
23767             out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages;
23768             out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments;
23769             out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources;
23770             out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers;
23771             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers;
23772             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
23773             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers;
23774             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
23775             out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages;
23776             out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages;
23777             out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments;
23778             out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes;
23779             out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes;
23780             out_ext->independentResolveNone = in_ext->independentResolveNone;
23781             out_ext->independentResolve = in_ext->independentResolve;
23782             out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats;
23783             out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping;
23784             out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference;
23785             out_ext->framebufferIntegerColorSampleCounts = in_ext->framebufferIntegerColorSampleCounts;
23786             out_header = (void *)out_ext;
23787             break;
23788         }
23789         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
23790         {
23791             VkPhysicalDeviceVulkan13Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES);
23792             const VkPhysicalDeviceVulkan13Properties *in_ext = (const VkPhysicalDeviceVulkan13Properties *)in_header;
23793             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
23794             out_ext->minSubgroupSize = in_ext->minSubgroupSize;
23795             out_ext->maxSubgroupSize = in_ext->maxSubgroupSize;
23796             out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups;
23797             out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages;
23798             out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize;
23799             out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks;
23800             out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
23801             out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks;
23802             out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
23803             out_ext->maxInlineUniformTotalSize = in_ext->maxInlineUniformTotalSize;
23804             out_ext->integerDotProduct8BitUnsignedAccelerated = in_ext->integerDotProduct8BitUnsignedAccelerated;
23805             out_ext->integerDotProduct8BitSignedAccelerated = in_ext->integerDotProduct8BitSignedAccelerated;
23806             out_ext->integerDotProduct8BitMixedSignednessAccelerated = in_ext->integerDotProduct8BitMixedSignednessAccelerated;
23807             out_ext->integerDotProduct4x8BitPackedUnsignedAccelerated = in_ext->integerDotProduct4x8BitPackedUnsignedAccelerated;
23808             out_ext->integerDotProduct4x8BitPackedSignedAccelerated = in_ext->integerDotProduct4x8BitPackedSignedAccelerated;
23809             out_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated;
23810             out_ext->integerDotProduct16BitUnsignedAccelerated = in_ext->integerDotProduct16BitUnsignedAccelerated;
23811             out_ext->integerDotProduct16BitSignedAccelerated = in_ext->integerDotProduct16BitSignedAccelerated;
23812             out_ext->integerDotProduct16BitMixedSignednessAccelerated = in_ext->integerDotProduct16BitMixedSignednessAccelerated;
23813             out_ext->integerDotProduct32BitUnsignedAccelerated = in_ext->integerDotProduct32BitUnsignedAccelerated;
23814             out_ext->integerDotProduct32BitSignedAccelerated = in_ext->integerDotProduct32BitSignedAccelerated;
23815             out_ext->integerDotProduct32BitMixedSignednessAccelerated = in_ext->integerDotProduct32BitMixedSignednessAccelerated;
23816             out_ext->integerDotProduct64BitUnsignedAccelerated = in_ext->integerDotProduct64BitUnsignedAccelerated;
23817             out_ext->integerDotProduct64BitSignedAccelerated = in_ext->integerDotProduct64BitSignedAccelerated;
23818             out_ext->integerDotProduct64BitMixedSignednessAccelerated = in_ext->integerDotProduct64BitMixedSignednessAccelerated;
23819             out_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
23820             out_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated;
23821             out_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
23822             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
23823             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
23824             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
23825             out_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
23826             out_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated;
23827             out_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
23828             out_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
23829             out_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated;
23830             out_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
23831             out_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
23832             out_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated;
23833             out_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
23834             out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes;
23835             out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment;
23836             out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes;
23837             out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment;
23838             out_ext->maxBufferSize = in_ext->maxBufferSize;
23839             out_header = (void *)out_ext;
23840             break;
23841         }
23842         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
23843         {
23844             VkPhysicalDeviceCustomBorderColorPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT);
23845             const VkPhysicalDeviceCustomBorderColorPropertiesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorPropertiesEXT *)in_header;
23846             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
23847             out_ext->maxCustomBorderColorSamplers = in_ext->maxCustomBorderColorSamplers;
23848             out_header = (void *)out_ext;
23849             break;
23850         }
23851         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
23852         {
23853             VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT);
23854             const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *)in_header;
23855             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
23856             out_ext->dynamicPrimitiveTopologyUnrestricted = in_ext->dynamicPrimitiveTopologyUnrestricted;
23857             out_header = (void *)out_ext;
23858             break;
23859         }
23860         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
23861         {
23862             VkPhysicalDeviceRobustness2PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT);
23863             const VkPhysicalDeviceRobustness2PropertiesEXT *in_ext = (const VkPhysicalDeviceRobustness2PropertiesEXT *)in_header;
23864             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT;
23865             out_ext->robustStorageBufferAccessSizeAlignment = in_ext->robustStorageBufferAccessSizeAlignment;
23866             out_ext->robustUniformBufferAccessSizeAlignment = in_ext->robustUniformBufferAccessSizeAlignment;
23867             out_header = (void *)out_ext;
23868             break;
23869         }
23870         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
23871         {
23872             VkPhysicalDeviceFragmentShadingRatePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR);
23873             const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)in_header;
23874             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
23875             out_ext->minFragmentShadingRateAttachmentTexelSize = in_ext->minFragmentShadingRateAttachmentTexelSize;
23876             out_ext->maxFragmentShadingRateAttachmentTexelSize = in_ext->maxFragmentShadingRateAttachmentTexelSize;
23877             out_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio = in_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
23878             out_ext->primitiveFragmentShadingRateWithMultipleViewports = in_ext->primitiveFragmentShadingRateWithMultipleViewports;
23879             out_ext->layeredShadingRateAttachments = in_ext->layeredShadingRateAttachments;
23880             out_ext->fragmentShadingRateNonTrivialCombinerOps = in_ext->fragmentShadingRateNonTrivialCombinerOps;
23881             out_ext->maxFragmentSize = in_ext->maxFragmentSize;
23882             out_ext->maxFragmentSizeAspectRatio = in_ext->maxFragmentSizeAspectRatio;
23883             out_ext->maxFragmentShadingRateCoverageSamples = in_ext->maxFragmentShadingRateCoverageSamples;
23884             out_ext->maxFragmentShadingRateRasterizationSamples = in_ext->maxFragmentShadingRateRasterizationSamples;
23885             out_ext->fragmentShadingRateWithShaderDepthStencilWrites = in_ext->fragmentShadingRateWithShaderDepthStencilWrites;
23886             out_ext->fragmentShadingRateWithSampleMask = in_ext->fragmentShadingRateWithSampleMask;
23887             out_ext->fragmentShadingRateWithShaderSampleMask = in_ext->fragmentShadingRateWithShaderSampleMask;
23888             out_ext->fragmentShadingRateWithConservativeRasterization = in_ext->fragmentShadingRateWithConservativeRasterization;
23889             out_ext->fragmentShadingRateWithFragmentShaderInterlock = in_ext->fragmentShadingRateWithFragmentShaderInterlock;
23890             out_ext->fragmentShadingRateWithCustomSampleLocations = in_ext->fragmentShadingRateWithCustomSampleLocations;
23891             out_ext->fragmentShadingRateStrictMultiplyCombiner = in_ext->fragmentShadingRateStrictMultiplyCombiner;
23892             out_header = (void *)out_ext;
23893             break;
23894         }
23895         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
23896         {
23897             VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV);
23898             const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *)in_header;
23899             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV;
23900             out_ext->maxFragmentShadingRateInvocationCount = in_ext->maxFragmentShadingRateInvocationCount;
23901             out_header = (void *)out_ext;
23902             break;
23903         }
23904         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
23905         {
23906             VkPhysicalDeviceProvokingVertexPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT);
23907             const VkPhysicalDeviceProvokingVertexPropertiesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexPropertiesEXT *)in_header;
23908             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
23909             out_ext->provokingVertexModePerPipeline = in_ext->provokingVertexModePerPipeline;
23910             out_ext->transformFeedbackPreservesTriangleFanProvokingVertex = in_ext->transformFeedbackPreservesTriangleFanProvokingVertex;
23911             out_header = (void *)out_ext;
23912             break;
23913         }
23914         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
23915         {
23916             VkPhysicalDeviceDescriptorBufferPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT);
23917             const VkPhysicalDeviceDescriptorBufferPropertiesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferPropertiesEXT *)in_header;
23918             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT;
23919             out_ext->combinedImageSamplerDescriptorSingleArray = in_ext->combinedImageSamplerDescriptorSingleArray;
23920             out_ext->bufferlessPushDescriptors = in_ext->bufferlessPushDescriptors;
23921             out_ext->allowSamplerImageViewPostSubmitCreation = in_ext->allowSamplerImageViewPostSubmitCreation;
23922             out_ext->descriptorBufferOffsetAlignment = in_ext->descriptorBufferOffsetAlignment;
23923             out_ext->maxDescriptorBufferBindings = in_ext->maxDescriptorBufferBindings;
23924             out_ext->maxResourceDescriptorBufferBindings = in_ext->maxResourceDescriptorBufferBindings;
23925             out_ext->maxSamplerDescriptorBufferBindings = in_ext->maxSamplerDescriptorBufferBindings;
23926             out_ext->maxEmbeddedImmutableSamplerBindings = in_ext->maxEmbeddedImmutableSamplerBindings;
23927             out_ext->maxEmbeddedImmutableSamplers = in_ext->maxEmbeddedImmutableSamplers;
23928             out_ext->bufferCaptureReplayDescriptorDataSize = in_ext->bufferCaptureReplayDescriptorDataSize;
23929             out_ext->imageCaptureReplayDescriptorDataSize = in_ext->imageCaptureReplayDescriptorDataSize;
23930             out_ext->imageViewCaptureReplayDescriptorDataSize = in_ext->imageViewCaptureReplayDescriptorDataSize;
23931             out_ext->samplerCaptureReplayDescriptorDataSize = in_ext->samplerCaptureReplayDescriptorDataSize;
23932             out_ext->accelerationStructureCaptureReplayDescriptorDataSize = in_ext->accelerationStructureCaptureReplayDescriptorDataSize;
23933             out_ext->samplerDescriptorSize = in_ext->samplerDescriptorSize;
23934             out_ext->combinedImageSamplerDescriptorSize = in_ext->combinedImageSamplerDescriptorSize;
23935             out_ext->sampledImageDescriptorSize = in_ext->sampledImageDescriptorSize;
23936             out_ext->storageImageDescriptorSize = in_ext->storageImageDescriptorSize;
23937             out_ext->uniformTexelBufferDescriptorSize = in_ext->uniformTexelBufferDescriptorSize;
23938             out_ext->robustUniformTexelBufferDescriptorSize = in_ext->robustUniformTexelBufferDescriptorSize;
23939             out_ext->storageTexelBufferDescriptorSize = in_ext->storageTexelBufferDescriptorSize;
23940             out_ext->robustStorageTexelBufferDescriptorSize = in_ext->robustStorageTexelBufferDescriptorSize;
23941             out_ext->uniformBufferDescriptorSize = in_ext->uniformBufferDescriptorSize;
23942             out_ext->robustUniformBufferDescriptorSize = in_ext->robustUniformBufferDescriptorSize;
23943             out_ext->storageBufferDescriptorSize = in_ext->storageBufferDescriptorSize;
23944             out_ext->robustStorageBufferDescriptorSize = in_ext->robustStorageBufferDescriptorSize;
23945             out_ext->inputAttachmentDescriptorSize = in_ext->inputAttachmentDescriptorSize;
23946             out_ext->accelerationStructureDescriptorSize = in_ext->accelerationStructureDescriptorSize;
23947             out_ext->maxSamplerDescriptorBufferRange = in_ext->maxSamplerDescriptorBufferRange;
23948             out_ext->maxResourceDescriptorBufferRange = in_ext->maxResourceDescriptorBufferRange;
23949             out_ext->samplerDescriptorBufferAddressSpaceSize = in_ext->samplerDescriptorBufferAddressSpaceSize;
23950             out_ext->resourceDescriptorBufferAddressSpaceSize = in_ext->resourceDescriptorBufferAddressSpaceSize;
23951             out_ext->descriptorBufferAddressSpaceSize = in_ext->descriptorBufferAddressSpaceSize;
23952             out_header = (void *)out_ext;
23953             break;
23954         }
23955         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
23956         {
23957             VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT);
23958             const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *)in_header;
23959             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT;
23960             out_ext->combinedImageSamplerDensityMapDescriptorSize = in_ext->combinedImageSamplerDensityMapDescriptorSize;
23961             out_header = (void *)out_ext;
23962             break;
23963         }
23964         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
23965         {
23966             VkPhysicalDeviceShaderIntegerDotProductProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES);
23967             const VkPhysicalDeviceShaderIntegerDotProductProperties *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductProperties *)in_header;
23968             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
23969             out_ext->integerDotProduct8BitUnsignedAccelerated = in_ext->integerDotProduct8BitUnsignedAccelerated;
23970             out_ext->integerDotProduct8BitSignedAccelerated = in_ext->integerDotProduct8BitSignedAccelerated;
23971             out_ext->integerDotProduct8BitMixedSignednessAccelerated = in_ext->integerDotProduct8BitMixedSignednessAccelerated;
23972             out_ext->integerDotProduct4x8BitPackedUnsignedAccelerated = in_ext->integerDotProduct4x8BitPackedUnsignedAccelerated;
23973             out_ext->integerDotProduct4x8BitPackedSignedAccelerated = in_ext->integerDotProduct4x8BitPackedSignedAccelerated;
23974             out_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated;
23975             out_ext->integerDotProduct16BitUnsignedAccelerated = in_ext->integerDotProduct16BitUnsignedAccelerated;
23976             out_ext->integerDotProduct16BitSignedAccelerated = in_ext->integerDotProduct16BitSignedAccelerated;
23977             out_ext->integerDotProduct16BitMixedSignednessAccelerated = in_ext->integerDotProduct16BitMixedSignednessAccelerated;
23978             out_ext->integerDotProduct32BitUnsignedAccelerated = in_ext->integerDotProduct32BitUnsignedAccelerated;
23979             out_ext->integerDotProduct32BitSignedAccelerated = in_ext->integerDotProduct32BitSignedAccelerated;
23980             out_ext->integerDotProduct32BitMixedSignednessAccelerated = in_ext->integerDotProduct32BitMixedSignednessAccelerated;
23981             out_ext->integerDotProduct64BitUnsignedAccelerated = in_ext->integerDotProduct64BitUnsignedAccelerated;
23982             out_ext->integerDotProduct64BitSignedAccelerated = in_ext->integerDotProduct64BitSignedAccelerated;
23983             out_ext->integerDotProduct64BitMixedSignednessAccelerated = in_ext->integerDotProduct64BitMixedSignednessAccelerated;
23984             out_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
23985             out_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated;
23986             out_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
23987             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
23988             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
23989             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
23990             out_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
23991             out_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated;
23992             out_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
23993             out_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
23994             out_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated;
23995             out_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
23996             out_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
23997             out_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated;
23998             out_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
23999             out_header = (void *)out_ext;
24000             break;
24001         }
24002         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
24003         {
24004             VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR);
24005             const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *)in_header;
24006             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
24007             out_ext->triStripVertexOrderIndependentOfProvokingVertex = in_ext->triStripVertexOrderIndependentOfProvokingVertex;
24008             out_header = (void *)out_ext;
24009             break;
24010         }
24011         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
24012         {
24013             VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT);
24014             const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *)in_header;
24015             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
24016             out_ext->graphicsPipelineLibraryFastLinking = in_ext->graphicsPipelineLibraryFastLinking;
24017             out_ext->graphicsPipelineLibraryIndependentInterpolationDecoration = in_ext->graphicsPipelineLibraryIndependentInterpolationDecoration;
24018             out_header = (void *)out_ext;
24019             break;
24020         }
24021         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
24022         {
24023             VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT);
24024             const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *)in_header;
24025             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
24026             memcpy(out_ext->shaderModuleIdentifierAlgorithmUUID, in_ext->shaderModuleIdentifierAlgorithmUUID, VK_UUID_SIZE * sizeof(uint8_t));
24027             out_header = (void *)out_ext;
24028             break;
24029         }
24030         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
24031         {
24032             VkPhysicalDeviceOpacityMicromapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT);
24033             const VkPhysicalDeviceOpacityMicromapPropertiesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapPropertiesEXT *)in_header;
24034             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
24035             out_ext->maxOpacity2StateSubdivisionLevel = in_ext->maxOpacity2StateSubdivisionLevel;
24036             out_ext->maxOpacity4StateSubdivisionLevel = in_ext->maxOpacity4StateSubdivisionLevel;
24037             out_header = (void *)out_ext;
24038             break;
24039         }
24040         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
24041         {
24042             VkPhysicalDevicePipelineRobustnessPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT);
24043             const VkPhysicalDevicePipelineRobustnessPropertiesEXT *in_ext = (const VkPhysicalDevicePipelineRobustnessPropertiesEXT *)in_header;
24044             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT;
24045             out_ext->defaultRobustnessStorageBuffers = in_ext->defaultRobustnessStorageBuffers;
24046             out_ext->defaultRobustnessUniformBuffers = in_ext->defaultRobustnessUniformBuffers;
24047             out_ext->defaultRobustnessVertexInputs = in_ext->defaultRobustnessVertexInputs;
24048             out_ext->defaultRobustnessImages = in_ext->defaultRobustnessImages;
24049             out_header = (void *)out_ext;
24050             break;
24051         }
24052         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
24053         {
24054             VkPhysicalDeviceImageProcessingPropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM);
24055             const VkPhysicalDeviceImageProcessingPropertiesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingPropertiesQCOM *)in_header;
24056             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM;
24057             out_ext->maxWeightFilterPhases = in_ext->maxWeightFilterPhases;
24058             out_ext->maxWeightFilterDimension = in_ext->maxWeightFilterDimension;
24059             out_ext->maxBlockMatchRegion = in_ext->maxBlockMatchRegion;
24060             out_ext->maxBoxFilterBlockSize = in_ext->maxBoxFilterBlockSize;
24061             out_header = (void *)out_ext;
24062             break;
24063         }
24064         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
24065         {
24066             VkPhysicalDeviceOpticalFlowPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV);
24067             const VkPhysicalDeviceOpticalFlowPropertiesNV *in_ext = (const VkPhysicalDeviceOpticalFlowPropertiesNV *)in_header;
24068             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV;
24069             out_ext->supportedOutputGridSizes = in_ext->supportedOutputGridSizes;
24070             out_ext->supportedHintGridSizes = in_ext->supportedHintGridSizes;
24071             out_ext->hintSupported = in_ext->hintSupported;
24072             out_ext->costSupported = in_ext->costSupported;
24073             out_ext->bidirectionalFlowSupported = in_ext->bidirectionalFlowSupported;
24074             out_ext->globalFlowSupported = in_ext->globalFlowSupported;
24075             out_ext->minWidth = in_ext->minWidth;
24076             out_ext->minHeight = in_ext->minHeight;
24077             out_ext->maxWidth = in_ext->maxWidth;
24078             out_ext->maxHeight = in_ext->maxHeight;
24079             out_ext->maxNumRegionsOfInterest = in_ext->maxNumRegionsOfInterest;
24080             out_header = (void *)out_ext;
24081             break;
24082         }
24083         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
24084         {
24085             VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM);
24086             const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *)in_header;
24087             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM;
24088             out_ext->shaderCoreMask = in_ext->shaderCoreMask;
24089             out_ext->shaderCoreCount = in_ext->shaderCoreCount;
24090             out_ext->shaderWarpsPerCore = in_ext->shaderWarpsPerCore;
24091             out_header = (void *)out_ext;
24092             break;
24093         }
24094         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
24095         {
24096             VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV);
24097             const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *)in_header;
24098             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV;
24099             out_ext->rayTracingInvocationReorderReorderingHint = in_ext->rayTracingInvocationReorderReorderingHint;
24100             out_header = (void *)out_ext;
24101             break;
24102         }
24103         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
24104         {
24105             VkPhysicalDeviceShaderCorePropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM);
24106             const VkPhysicalDeviceShaderCorePropertiesARM *in_ext = (const VkPhysicalDeviceShaderCorePropertiesARM *)in_header;
24107             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM;
24108             out_ext->pixelRate = in_ext->pixelRate;
24109             out_ext->texelRate = in_ext->texelRate;
24110             out_ext->fmaRate = in_ext->fmaRate;
24111             out_header = (void *)out_ext;
24112             break;
24113         }
24114         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
24115         {
24116             VkPhysicalDeviceShaderObjectPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT);
24117             const VkPhysicalDeviceShaderObjectPropertiesEXT *in_ext = (const VkPhysicalDeviceShaderObjectPropertiesEXT *)in_header;
24118             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT;
24119             memcpy(out_ext->shaderBinaryUUID, in_ext->shaderBinaryUUID, VK_UUID_SIZE * sizeof(uint8_t));
24120             out_ext->shaderBinaryVersion = in_ext->shaderBinaryVersion;
24121             out_header = (void *)out_ext;
24122             break;
24123         }
24124         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
24125         {
24126             VkPhysicalDeviceShaderTileImagePropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT);
24127             const VkPhysicalDeviceShaderTileImagePropertiesEXT *in_ext = (const VkPhysicalDeviceShaderTileImagePropertiesEXT *)in_header;
24128             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT;
24129             out_ext->shaderTileImageCoherentReadAccelerated = in_ext->shaderTileImageCoherentReadAccelerated;
24130             out_ext->shaderTileImageReadSampleFromPixelRateInvocation = in_ext->shaderTileImageReadSampleFromPixelRateInvocation;
24131             out_ext->shaderTileImageReadFromHelperInvocation = in_ext->shaderTileImageReadFromHelperInvocation;
24132             out_header = (void *)out_ext;
24133             break;
24134         }
24135         default:
24136             break;
24137         }
24138     }
24139 }
24140
24141 static inline void convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host(const VkQueryPoolPerformanceCreateInfoKHR32 *in, VkQueryPoolPerformanceCreateInfoKHR *out)
24142 {
24143     if (!in) return;
24144
24145     out->sType = in->sType;
24146     out->pNext = NULL;
24147     out->queueFamilyIndex = in->queueFamilyIndex;
24148     out->counterIndexCount = in->counterIndexCount;
24149     out->pCounterIndices = (const uint32_t *)UlongToPtr(in->pCounterIndices);
24150     if (in->pNext)
24151         FIXME("Unexpected pNext\n");
24152 }
24153
24154 static inline void convert_VkQueueFamilyProperties2_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyProperties232 *in, VkQueueFamilyProperties2 *out)
24155 {
24156     const VkBaseInStructure32 *in_header;
24157     VkBaseOutStructure *out_header = (void *)out;
24158
24159     if (!in) return;
24160
24161     out->sType = in->sType;
24162     out->pNext = NULL;
24163
24164     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
24165     {
24166         switch (in_header->sType)
24167         {
24168         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
24169         {
24170             VkQueueFamilyGlobalPriorityPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24171             const VkQueueFamilyGlobalPriorityPropertiesKHR32 *in_ext = (const VkQueueFamilyGlobalPriorityPropertiesKHR32 *)in_header;
24172             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR;
24173             out_ext->pNext = NULL;
24174             out_ext->priorityCount = in_ext->priorityCount;
24175             memcpy(out_ext->priorities, in_ext->priorities, VK_MAX_GLOBAL_PRIORITY_SIZE_KHR * sizeof(VkQueueGlobalPriorityKHR));
24176             out_header->pNext = (void *)out_ext;
24177             out_header = (void *)out_ext;
24178             break;
24179         }
24180         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
24181         {
24182             VkQueueFamilyCheckpointPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24183             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV;
24184             out_ext->pNext = NULL;
24185             out_header->pNext = (void *)out_ext;
24186             out_header = (void *)out_ext;
24187             break;
24188         }
24189         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
24190         {
24191             VkQueueFamilyCheckpointProperties2NV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24192             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV;
24193             out_ext->pNext = NULL;
24194             out_header->pNext = (void *)out_ext;
24195             out_header = (void *)out_ext;
24196             break;
24197         }
24198         default:
24199             FIXME("Unhandled sType %u.\n", in_header->sType);
24200             break;
24201         }
24202     }
24203 }
24204
24205 static inline void convert_VkQueueFamilyProperties2_host_to_win32(const VkQueueFamilyProperties2 *in, VkQueueFamilyProperties232 *out)
24206 {
24207     const VkBaseInStructure *in_header;
24208     VkBaseOutStructure32 *out_header = (void *)out;
24209
24210     if (!in) return;
24211
24212     out->queueFamilyProperties = in->queueFamilyProperties;
24213
24214     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
24215     {
24216         switch (in_header->sType)
24217         {
24218         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
24219         {
24220             VkQueueFamilyGlobalPriorityPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR);
24221             const VkQueueFamilyGlobalPriorityPropertiesKHR *in_ext = (const VkQueueFamilyGlobalPriorityPropertiesKHR *)in_header;
24222             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR;
24223             out_ext->priorityCount = in_ext->priorityCount;
24224             memcpy(out_ext->priorities, in_ext->priorities, VK_MAX_GLOBAL_PRIORITY_SIZE_KHR * sizeof(VkQueueGlobalPriorityKHR));
24225             out_header = (void *)out_ext;
24226             break;
24227         }
24228         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
24229         {
24230             VkQueueFamilyCheckpointPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV);
24231             const VkQueueFamilyCheckpointPropertiesNV *in_ext = (const VkQueueFamilyCheckpointPropertiesNV *)in_header;
24232             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV;
24233             out_ext->checkpointExecutionStageMask = in_ext->checkpointExecutionStageMask;
24234             out_header = (void *)out_ext;
24235             break;
24236         }
24237         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
24238         {
24239             VkQueueFamilyCheckpointProperties2NV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV);
24240             const VkQueueFamilyCheckpointProperties2NV *in_ext = (const VkQueueFamilyCheckpointProperties2NV *)in_header;
24241             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV;
24242             out_ext->checkpointExecutionStageMask = in_ext->checkpointExecutionStageMask;
24243             out_header = (void *)out_ext;
24244             break;
24245         }
24246         default:
24247             break;
24248         }
24249     }
24250 }
24251
24252 static inline VkQueueFamilyProperties2 *convert_VkQueueFamilyProperties2_array_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyProperties232 *in, uint32_t count)
24253 {
24254     VkQueueFamilyProperties2 *out;
24255     unsigned int i;
24256
24257     if (!in || !count) return NULL;
24258
24259     out = conversion_context_alloc(ctx, count * sizeof(*out));
24260     for (i = 0; i < count; i++)
24261     {
24262         convert_VkQueueFamilyProperties2_win32_to_host(ctx, &in[i], &out[i]);
24263     }
24264
24265     return out;
24266 }
24267
24268 static inline void convert_VkQueueFamilyProperties2_array_host_to_win32(const VkQueueFamilyProperties2 *in, VkQueueFamilyProperties232 *out, uint32_t count)
24269 {
24270     unsigned int i;
24271
24272     if (!in) return;
24273
24274     for (i = 0; i < count; i++)
24275     {
24276         convert_VkQueueFamilyProperties2_host_to_win32(&in[i], &out[i]);
24277     }
24278 }
24279
24280 static inline void convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(const VkPhysicalDeviceSparseImageFormatInfo232 *in, VkPhysicalDeviceSparseImageFormatInfo2 *out)
24281 {
24282     if (!in) return;
24283
24284     out->sType = in->sType;
24285     out->pNext = NULL;
24286     out->format = in->format;
24287     out->type = in->type;
24288     out->samples = in->samples;
24289     out->usage = in->usage;
24290     out->tiling = in->tiling;
24291     if (in->pNext)
24292         FIXME("Unexpected pNext\n");
24293 }
24294
24295 static inline void convert_VkSparseImageFormatProperties2_win32_to_host(const VkSparseImageFormatProperties232 *in, VkSparseImageFormatProperties2 *out)
24296 {
24297     if (!in) return;
24298
24299     out->sType = in->sType;
24300     out->pNext = NULL;
24301     if (in->pNext)
24302         FIXME("Unexpected pNext\n");
24303 }
24304
24305 static inline void convert_VkSparseImageFormatProperties2_host_to_win32(const VkSparseImageFormatProperties2 *in, VkSparseImageFormatProperties232 *out)
24306 {
24307     if (!in) return;
24308
24309     out->properties = in->properties;
24310 }
24311
24312 static inline VkSparseImageFormatProperties2 *convert_VkSparseImageFormatProperties2_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageFormatProperties232 *in, uint32_t count)
24313 {
24314     VkSparseImageFormatProperties2 *out;
24315     unsigned int i;
24316
24317     if (!in || !count) return NULL;
24318
24319     out = conversion_context_alloc(ctx, count * sizeof(*out));
24320     for (i = 0; i < count; i++)
24321     {
24322         convert_VkSparseImageFormatProperties2_win32_to_host(&in[i], &out[i]);
24323     }
24324
24325     return out;
24326 }
24327
24328 static inline void convert_VkSparseImageFormatProperties2_array_host_to_win32(const VkSparseImageFormatProperties2 *in, VkSparseImageFormatProperties232 *out, uint32_t count)
24329 {
24330     unsigned int i;
24331
24332     if (!in) return;
24333
24334     for (i = 0; i < count; i++)
24335     {
24336         convert_VkSparseImageFormatProperties2_host_to_win32(&in[i], &out[i]);
24337     }
24338 }
24339
24340 static inline void convert_VkFramebufferMixedSamplesCombinationNV_win32_to_host(const VkFramebufferMixedSamplesCombinationNV32 *in, VkFramebufferMixedSamplesCombinationNV *out)
24341 {
24342     if (!in) return;
24343
24344     out->sType = in->sType;
24345     out->pNext = NULL;
24346     if (in->pNext)
24347         FIXME("Unexpected pNext\n");
24348 }
24349
24350 static inline void convert_VkFramebufferMixedSamplesCombinationNV_host_to_win32(const VkFramebufferMixedSamplesCombinationNV *in, VkFramebufferMixedSamplesCombinationNV32 *out)
24351 {
24352     if (!in) return;
24353
24354     out->coverageReductionMode = in->coverageReductionMode;
24355     out->rasterizationSamples = in->rasterizationSamples;
24356     out->depthStencilSamples = in->depthStencilSamples;
24357     out->colorSamples = in->colorSamples;
24358 }
24359
24360 static inline VkFramebufferMixedSamplesCombinationNV *convert_VkFramebufferMixedSamplesCombinationNV_array_win32_to_host(struct conversion_context *ctx, const VkFramebufferMixedSamplesCombinationNV32 *in, uint32_t count)
24361 {
24362     VkFramebufferMixedSamplesCombinationNV *out;
24363     unsigned int i;
24364
24365     if (!in || !count) return NULL;
24366
24367     out = conversion_context_alloc(ctx, count * sizeof(*out));
24368     for (i = 0; i < count; i++)
24369     {
24370         convert_VkFramebufferMixedSamplesCombinationNV_win32_to_host(&in[i], &out[i]);
24371     }
24372
24373     return out;
24374 }
24375
24376 static inline void convert_VkFramebufferMixedSamplesCombinationNV_array_host_to_win32(const VkFramebufferMixedSamplesCombinationNV *in, VkFramebufferMixedSamplesCombinationNV32 *out, uint32_t count)
24377 {
24378     unsigned int i;
24379
24380     if (!in) return;
24381
24382     for (i = 0; i < count; i++)
24383     {
24384         convert_VkFramebufferMixedSamplesCombinationNV_host_to_win32(&in[i], &out[i]);
24385     }
24386 }
24387
24388 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPhysicalDeviceSurfaceInfo2KHR32 *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
24389 {
24390     const VkBaseInStructure32 *in_header;
24391     VkBaseOutStructure *out_header = (void *)out;
24392
24393     if (!in) return;
24394
24395     out->sType = in->sType;
24396     out->pNext = NULL;
24397     out->surface = in->surface;
24398
24399     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
24400     {
24401         switch (in_header->sType)
24402         {
24403         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
24404         {
24405             VkSurfacePresentModeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24406             const VkSurfacePresentModeEXT32 *in_ext = (const VkSurfacePresentModeEXT32 *)in_header;
24407             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT;
24408             out_ext->pNext = NULL;
24409             out_ext->presentMode = in_ext->presentMode;
24410             out_header->pNext = (void *)out_ext;
24411             out_header = (void *)out_ext;
24412             break;
24413         }
24414         default:
24415             FIXME("Unhandled sType %u.\n", in_header->sType);
24416             break;
24417         }
24418     }
24419 }
24420
24421 static inline void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conversion_context *ctx, const VkSurfaceCapabilities2KHR32 *in, VkSurfaceCapabilities2KHR *out)
24422 {
24423     const VkBaseInStructure32 *in_header;
24424     VkBaseOutStructure *out_header = (void *)out;
24425
24426     if (!in) return;
24427
24428     out->sType = in->sType;
24429     out->pNext = NULL;
24430
24431     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
24432     {
24433         switch (in_header->sType)
24434         {
24435         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
24436         {
24437             VkSurfaceCapabilitiesPresentBarrierNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24438             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV;
24439             out_ext->pNext = NULL;
24440             out_header->pNext = (void *)out_ext;
24441             out_header = (void *)out_ext;
24442             break;
24443         }
24444         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT:
24445         {
24446             VkSurfacePresentScalingCapabilitiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24447             const VkSurfacePresentScalingCapabilitiesEXT32 *in_ext = (const VkSurfacePresentScalingCapabilitiesEXT32 *)in_header;
24448             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT;
24449             out_ext->pNext = NULL;
24450             out_ext->supportedPresentScaling = in_ext->supportedPresentScaling;
24451             out_ext->supportedPresentGravityX = in_ext->supportedPresentGravityX;
24452             out_ext->supportedPresentGravityY = in_ext->supportedPresentGravityY;
24453             out_ext->minScaledImageExtent = in_ext->minScaledImageExtent;
24454             out_ext->maxScaledImageExtent = in_ext->maxScaledImageExtent;
24455             out_header->pNext = (void *)out_ext;
24456             out_header = (void *)out_ext;
24457             break;
24458         }
24459         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT:
24460         {
24461             VkSurfacePresentModeCompatibilityEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24462             const VkSurfacePresentModeCompatibilityEXT32 *in_ext = (const VkSurfacePresentModeCompatibilityEXT32 *)in_header;
24463             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT;
24464             out_ext->pNext = NULL;
24465             out_ext->presentModeCount = in_ext->presentModeCount;
24466             out_ext->pPresentModes = (VkPresentModeKHR *)UlongToPtr(in_ext->pPresentModes);
24467             out_header->pNext = (void *)out_ext;
24468             out_header = (void *)out_ext;
24469             break;
24470         }
24471         default:
24472             FIXME("Unhandled sType %u.\n", in_header->sType);
24473             break;
24474         }
24475     }
24476 }
24477
24478 static inline void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfaceCapabilities2KHR *in, VkSurfaceCapabilities2KHR32 *out)
24479 {
24480     const VkBaseInStructure *in_header;
24481     VkBaseOutStructure32 *out_header = (void *)out;
24482
24483     if (!in) return;
24484
24485     out->surfaceCapabilities = in->surfaceCapabilities;
24486
24487     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
24488     {
24489         switch (in_header->sType)
24490         {
24491         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
24492         {
24493             VkSurfaceCapabilitiesPresentBarrierNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV);
24494             const VkSurfaceCapabilitiesPresentBarrierNV *in_ext = (const VkSurfaceCapabilitiesPresentBarrierNV *)in_header;
24495             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV;
24496             out_ext->presentBarrierSupported = in_ext->presentBarrierSupported;
24497             out_header = (void *)out_ext;
24498             break;
24499         }
24500         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT:
24501         {
24502             VkSurfacePresentScalingCapabilitiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT);
24503             const VkSurfacePresentScalingCapabilitiesEXT *in_ext = (const VkSurfacePresentScalingCapabilitiesEXT *)in_header;
24504             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT;
24505             out_ext->supportedPresentScaling = in_ext->supportedPresentScaling;
24506             out_ext->supportedPresentGravityX = in_ext->supportedPresentGravityX;
24507             out_ext->supportedPresentGravityY = in_ext->supportedPresentGravityY;
24508             out_ext->minScaledImageExtent = in_ext->minScaledImageExtent;
24509             out_ext->maxScaledImageExtent = in_ext->maxScaledImageExtent;
24510             out_header = (void *)out_ext;
24511             break;
24512         }
24513         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT:
24514         {
24515             VkSurfacePresentModeCompatibilityEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT);
24516             const VkSurfacePresentModeCompatibilityEXT *in_ext = (const VkSurfacePresentModeCompatibilityEXT *)in_header;
24517             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT;
24518             out_ext->presentModeCount = in_ext->presentModeCount;
24519             out_ext->pPresentModes = PtrToUlong(in_ext->pPresentModes);
24520             out_header = (void *)out_ext;
24521             break;
24522         }
24523         default:
24524             break;
24525         }
24526     }
24527 }
24528
24529 #ifdef _WIN64
24530 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win64_to_host(const VkPhysicalDeviceSurfaceInfo2KHR *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
24531 {
24532     if (!in) return;
24533
24534     out->sType = in->sType;
24535     out->pNext = in->pNext;
24536     out->surface = in->surface ? wine_surface_from_handle(in->surface)->driver_surface : 0;
24537 }
24538 #endif /* _WIN64 */
24539
24540 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceSurfaceInfo2KHR32 *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
24541 {
24542     const VkBaseInStructure32 *in_header;
24543     VkBaseOutStructure *out_header = (void *)out;
24544
24545     if (!in) return;
24546
24547     out->sType = in->sType;
24548     out->pNext = NULL;
24549     out->surface = in->surface ? wine_surface_from_handle(in->surface)->driver_surface : 0;
24550
24551     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
24552     {
24553         switch (in_header->sType)
24554         {
24555         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
24556         {
24557             VkSurfacePresentModeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24558             const VkSurfacePresentModeEXT32 *in_ext = (const VkSurfacePresentModeEXT32 *)in_header;
24559             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT;
24560             out_ext->pNext = NULL;
24561             out_ext->presentMode = in_ext->presentMode;
24562             out_header->pNext = (void *)out_ext;
24563             out_header = (void *)out_ext;
24564             break;
24565         }
24566         default:
24567             FIXME("Unhandled sType %u.\n", in_header->sType);
24568             break;
24569         }
24570     }
24571 }
24572
24573 static inline void convert_VkSurfaceFormat2KHR_win32_to_host(struct conversion_context *ctx, const VkSurfaceFormat2KHR32 *in, VkSurfaceFormat2KHR *out)
24574 {
24575     const VkBaseInStructure32 *in_header;
24576     VkBaseOutStructure *out_header = (void *)out;
24577
24578     if (!in) return;
24579
24580     out->sType = in->sType;
24581     out->pNext = NULL;
24582
24583     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
24584     {
24585         switch (in_header->sType)
24586         {
24587         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
24588         {
24589             VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24590             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
24591             out_ext->pNext = NULL;
24592             out_header->pNext = (void *)out_ext;
24593             out_header = (void *)out_ext;
24594             break;
24595         }
24596         default:
24597             FIXME("Unhandled sType %u.\n", in_header->sType);
24598             break;
24599         }
24600     }
24601 }
24602
24603 static inline void convert_VkSurfaceFormat2KHR_host_to_win32(const VkSurfaceFormat2KHR *in, VkSurfaceFormat2KHR32 *out)
24604 {
24605     const VkBaseInStructure *in_header;
24606     VkBaseOutStructure32 *out_header = (void *)out;
24607
24608     if (!in) return;
24609
24610     out->surfaceFormat = in->surfaceFormat;
24611
24612     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
24613     {
24614         switch (in_header->sType)
24615         {
24616         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
24617         {
24618             VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT);
24619             const VkImageCompressionPropertiesEXT *in_ext = (const VkImageCompressionPropertiesEXT *)in_header;
24620             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
24621             out_ext->imageCompressionFlags = in_ext->imageCompressionFlags;
24622             out_ext->imageCompressionFixedRateFlags = in_ext->imageCompressionFixedRateFlags;
24623             out_header = (void *)out_ext;
24624             break;
24625         }
24626         default:
24627             break;
24628         }
24629     }
24630 }
24631
24632 static inline VkSurfaceFormat2KHR *convert_VkSurfaceFormat2KHR_array_win32_to_host(struct conversion_context *ctx, const VkSurfaceFormat2KHR32 *in, uint32_t count)
24633 {
24634     VkSurfaceFormat2KHR *out;
24635     unsigned int i;
24636
24637     if (!in || !count) return NULL;
24638
24639     out = conversion_context_alloc(ctx, count * sizeof(*out));
24640     for (i = 0; i < count; i++)
24641     {
24642         convert_VkSurfaceFormat2KHR_win32_to_host(ctx, &in[i], &out[i]);
24643     }
24644
24645     return out;
24646 }
24647
24648 static inline void convert_VkSurfaceFormat2KHR_array_host_to_win32(const VkSurfaceFormat2KHR *in, VkSurfaceFormat2KHR32 *out, uint32_t count)
24649 {
24650     unsigned int i;
24651
24652     if (!in) return;
24653
24654     for (i = 0; i < count; i++)
24655     {
24656         convert_VkSurfaceFormat2KHR_host_to_win32(&in[i], &out[i]);
24657     }
24658 }
24659
24660 static inline void convert_VkPhysicalDeviceToolProperties_win32_to_host(const VkPhysicalDeviceToolProperties32 *in, VkPhysicalDeviceToolProperties *out)
24661 {
24662     if (!in) return;
24663
24664     out->sType = in->sType;
24665     out->pNext = NULL;
24666     if (in->pNext)
24667         FIXME("Unexpected pNext\n");
24668 }
24669
24670 static inline void convert_VkPhysicalDeviceToolProperties_host_to_win32(const VkPhysicalDeviceToolProperties *in, VkPhysicalDeviceToolProperties32 *out)
24671 {
24672     if (!in) return;
24673
24674     memcpy(out->name, in->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
24675     memcpy(out->version, in->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
24676     out->purposes = in->purposes;
24677     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
24678     memcpy(out->layer, in->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
24679 }
24680
24681 static inline VkPhysicalDeviceToolProperties *convert_VkPhysicalDeviceToolProperties_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceToolProperties32 *in, uint32_t count)
24682 {
24683     VkPhysicalDeviceToolProperties *out;
24684     unsigned int i;
24685
24686     if (!in || !count) return NULL;
24687
24688     out = conversion_context_alloc(ctx, count * sizeof(*out));
24689     for (i = 0; i < count; i++)
24690     {
24691         convert_VkPhysicalDeviceToolProperties_win32_to_host(&in[i], &out[i]);
24692     }
24693
24694     return out;
24695 }
24696
24697 static inline void convert_VkPhysicalDeviceToolProperties_array_host_to_win32(const VkPhysicalDeviceToolProperties *in, VkPhysicalDeviceToolProperties32 *out, uint32_t count)
24698 {
24699     unsigned int i;
24700
24701     if (!in) return;
24702
24703     for (i = 0; i < count; i++)
24704     {
24705         convert_VkPhysicalDeviceToolProperties_host_to_win32(&in[i], &out[i]);
24706     }
24707 }
24708
24709 static inline void convert_VkPipelineExecutableInfoKHR_win32_to_host(const VkPipelineExecutableInfoKHR32 *in, VkPipelineExecutableInfoKHR *out)
24710 {
24711     if (!in) return;
24712
24713     out->sType = in->sType;
24714     out->pNext = NULL;
24715     out->pipeline = in->pipeline;
24716     out->executableIndex = in->executableIndex;
24717     if (in->pNext)
24718         FIXME("Unexpected pNext\n");
24719 }
24720
24721 static inline void convert_VkPipelineExecutableInternalRepresentationKHR_win32_to_host(const VkPipelineExecutableInternalRepresentationKHR32 *in, VkPipelineExecutableInternalRepresentationKHR *out)
24722 {
24723     if (!in) return;
24724
24725     out->sType = in->sType;
24726     out->pNext = NULL;
24727     if (in->pNext)
24728         FIXME("Unexpected pNext\n");
24729 }
24730
24731 static inline void convert_VkPipelineExecutableInternalRepresentationKHR_host_to_win32(const VkPipelineExecutableInternalRepresentationKHR *in, VkPipelineExecutableInternalRepresentationKHR32 *out)
24732 {
24733     if (!in) return;
24734
24735     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
24736     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
24737     out->isText = in->isText;
24738     out->dataSize = in->dataSize;
24739     out->pData = PtrToUlong(in->pData);
24740 }
24741
24742 static inline VkPipelineExecutableInternalRepresentationKHR *convert_VkPipelineExecutableInternalRepresentationKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableInternalRepresentationKHR32 *in, uint32_t count)
24743 {
24744     VkPipelineExecutableInternalRepresentationKHR *out;
24745     unsigned int i;
24746
24747     if (!in || !count) return NULL;
24748
24749     out = conversion_context_alloc(ctx, count * sizeof(*out));
24750     for (i = 0; i < count; i++)
24751     {
24752         convert_VkPipelineExecutableInternalRepresentationKHR_win32_to_host(&in[i], &out[i]);
24753     }
24754
24755     return out;
24756 }
24757
24758 static inline void convert_VkPipelineExecutableInternalRepresentationKHR_array_host_to_win32(const VkPipelineExecutableInternalRepresentationKHR *in, VkPipelineExecutableInternalRepresentationKHR32 *out, uint32_t count)
24759 {
24760     unsigned int i;
24761
24762     if (!in) return;
24763
24764     for (i = 0; i < count; i++)
24765     {
24766         convert_VkPipelineExecutableInternalRepresentationKHR_host_to_win32(&in[i], &out[i]);
24767     }
24768 }
24769
24770 static inline void convert_VkPipelineInfoKHR_win32_to_host(const VkPipelineInfoKHR32 *in, VkPipelineInfoKHR *out)
24771 {
24772     if (!in) return;
24773
24774     out->sType = in->sType;
24775     out->pNext = NULL;
24776     out->pipeline = in->pipeline;
24777     if (in->pNext)
24778         FIXME("Unexpected pNext\n");
24779 }
24780
24781 static inline void convert_VkPipelineExecutablePropertiesKHR_win32_to_host(const VkPipelineExecutablePropertiesKHR32 *in, VkPipelineExecutablePropertiesKHR *out)
24782 {
24783     if (!in) return;
24784
24785     out->sType = in->sType;
24786     out->pNext = NULL;
24787     if (in->pNext)
24788         FIXME("Unexpected pNext\n");
24789 }
24790
24791 static inline void convert_VkPipelineExecutablePropertiesKHR_host_to_win32(const VkPipelineExecutablePropertiesKHR *in, VkPipelineExecutablePropertiesKHR32 *out)
24792 {
24793     if (!in) return;
24794
24795     out->stages = in->stages;
24796     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
24797     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
24798     out->subgroupSize = in->subgroupSize;
24799 }
24800
24801 static inline VkPipelineExecutablePropertiesKHR *convert_VkPipelineExecutablePropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutablePropertiesKHR32 *in, uint32_t count)
24802 {
24803     VkPipelineExecutablePropertiesKHR *out;
24804     unsigned int i;
24805
24806     if (!in || !count) return NULL;
24807
24808     out = conversion_context_alloc(ctx, count * sizeof(*out));
24809     for (i = 0; i < count; i++)
24810     {
24811         convert_VkPipelineExecutablePropertiesKHR_win32_to_host(&in[i], &out[i]);
24812     }
24813
24814     return out;
24815 }
24816
24817 static inline void convert_VkPipelineExecutablePropertiesKHR_array_host_to_win32(const VkPipelineExecutablePropertiesKHR *in, VkPipelineExecutablePropertiesKHR32 *out, uint32_t count)
24818 {
24819     unsigned int i;
24820
24821     if (!in) return;
24822
24823     for (i = 0; i < count; i++)
24824     {
24825         convert_VkPipelineExecutablePropertiesKHR_host_to_win32(&in[i], &out[i]);
24826     }
24827 }
24828
24829 static inline void convert_VkPipelineExecutableStatisticValueKHR_host_to_win32(const VkPipelineExecutableStatisticValueKHR *in, VkPipelineExecutableStatisticValueKHR32 *out, VkFlags selector)
24830 {
24831     if (!in) return;
24832
24833     if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR)
24834         out->b32 = in->b32;
24835     if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR)
24836         out->i64 = in->i64;
24837     if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR)
24838         out->u64 = in->u64;
24839     if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR)
24840         out->f64 = in->f64;
24841 }
24842
24843 static inline void convert_VkPipelineExecutableStatisticKHR_win32_to_host(const VkPipelineExecutableStatisticKHR32 *in, VkPipelineExecutableStatisticKHR *out)
24844 {
24845     if (!in) return;
24846
24847     out->sType = in->sType;
24848     out->pNext = NULL;
24849     if (in->pNext)
24850         FIXME("Unexpected pNext\n");
24851 }
24852
24853 static inline void convert_VkPipelineExecutableStatisticKHR_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out)
24854 {
24855     if (!in) return;
24856
24857     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
24858     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
24859     out->format = in->format;
24860     convert_VkPipelineExecutableStatisticValueKHR_host_to_win32(&in->value, &out->value, in->format);
24861 }
24862
24863 static inline VkPipelineExecutableStatisticKHR *convert_VkPipelineExecutableStatisticKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableStatisticKHR32 *in, uint32_t count)
24864 {
24865     VkPipelineExecutableStatisticKHR *out;
24866     unsigned int i;
24867
24868     if (!in || !count) return NULL;
24869
24870     out = conversion_context_alloc(ctx, count * sizeof(*out));
24871     for (i = 0; i < count; i++)
24872     {
24873         convert_VkPipelineExecutableStatisticKHR_win32_to_host(&in[i], &out[i]);
24874     }
24875
24876     return out;
24877 }
24878
24879 static inline void convert_VkPipelineExecutableStatisticKHR_array_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out, uint32_t count)
24880 {
24881     unsigned int i;
24882
24883     if (!in) return;
24884
24885     for (i = 0; i < count; i++)
24886     {
24887         convert_VkPipelineExecutableStatisticKHR_host_to_win32(&in[i], &out[i]);
24888     }
24889 }
24890
24891 static inline void convert_VkPipelineInfoEXT_win32_to_host(const VkPipelineInfoEXT32 *in, VkPipelineInfoEXT *out)
24892 {
24893     if (!in) return;
24894
24895     out->sType = in->sType;
24896     out->pNext = NULL;
24897     out->pipeline = in->pipeline;
24898     if (in->pNext)
24899         FIXME("Unexpected pNext\n");
24900 }
24901
24902 static inline void convert_VkCheckpointData2NV_win32_to_host(const VkCheckpointData2NV32 *in, VkCheckpointData2NV *out)
24903 {
24904     if (!in) return;
24905
24906     out->sType = in->sType;
24907     out->pNext = NULL;
24908     if (in->pNext)
24909         FIXME("Unexpected pNext\n");
24910 }
24911
24912 static inline void convert_VkCheckpointData2NV_host_to_win32(const VkCheckpointData2NV *in, VkCheckpointData2NV32 *out)
24913 {
24914     if (!in) return;
24915
24916     out->stage = in->stage;
24917     out->pCheckpointMarker = PtrToUlong(in->pCheckpointMarker);
24918 }
24919
24920 static inline VkCheckpointData2NV *convert_VkCheckpointData2NV_array_win32_to_host(struct conversion_context *ctx, const VkCheckpointData2NV32 *in, uint32_t count)
24921 {
24922     VkCheckpointData2NV *out;
24923     unsigned int i;
24924
24925     if (!in || !count) return NULL;
24926
24927     out = conversion_context_alloc(ctx, count * sizeof(*out));
24928     for (i = 0; i < count; i++)
24929     {
24930         convert_VkCheckpointData2NV_win32_to_host(&in[i], &out[i]);
24931     }
24932
24933     return out;
24934 }
24935
24936 static inline void convert_VkCheckpointData2NV_array_host_to_win32(const VkCheckpointData2NV *in, VkCheckpointData2NV32 *out, uint32_t count)
24937 {
24938     unsigned int i;
24939
24940     if (!in) return;
24941
24942     for (i = 0; i < count; i++)
24943     {
24944         convert_VkCheckpointData2NV_host_to_win32(&in[i], &out[i]);
24945     }
24946 }
24947
24948 static inline void convert_VkCheckpointDataNV_win32_to_host(const VkCheckpointDataNV32 *in, VkCheckpointDataNV *out)
24949 {
24950     if (!in) return;
24951
24952     out->sType = in->sType;
24953     out->pNext = NULL;
24954     if (in->pNext)
24955         FIXME("Unexpected pNext\n");
24956 }
24957
24958 static inline void convert_VkCheckpointDataNV_host_to_win32(const VkCheckpointDataNV *in, VkCheckpointDataNV32 *out)
24959 {
24960     if (!in) return;
24961
24962     out->stage = in->stage;
24963     out->pCheckpointMarker = PtrToUlong(in->pCheckpointMarker);
24964 }
24965
24966 static inline VkCheckpointDataNV *convert_VkCheckpointDataNV_array_win32_to_host(struct conversion_context *ctx, const VkCheckpointDataNV32 *in, uint32_t count)
24967 {
24968     VkCheckpointDataNV *out;
24969     unsigned int i;
24970
24971     if (!in || !count) return NULL;
24972
24973     out = conversion_context_alloc(ctx, count * sizeof(*out));
24974     for (i = 0; i < count; i++)
24975     {
24976         convert_VkCheckpointDataNV_win32_to_host(&in[i], &out[i]);
24977     }
24978
24979     return out;
24980 }
24981
24982 static inline void convert_VkCheckpointDataNV_array_host_to_win32(const VkCheckpointDataNV *in, VkCheckpointDataNV32 *out, uint32_t count)
24983 {
24984     unsigned int i;
24985
24986     if (!in) return;
24987
24988     for (i = 0; i < count; i++)
24989     {
24990         convert_VkCheckpointDataNV_host_to_win32(&in[i], &out[i]);
24991     }
24992 }
24993
24994 static inline void convert_VkSamplerCaptureDescriptorDataInfoEXT_win32_to_host(const VkSamplerCaptureDescriptorDataInfoEXT32 *in, VkSamplerCaptureDescriptorDataInfoEXT *out)
24995 {
24996     if (!in) return;
24997
24998     out->sType = in->sType;
24999     out->pNext = NULL;
25000     out->sampler = in->sampler;
25001     if (in->pNext)
25002         FIXME("Unexpected pNext\n");
25003 }
25004
25005 static inline void convert_VkShaderModuleIdentifierEXT_win32_to_host(const VkShaderModuleIdentifierEXT32 *in, VkShaderModuleIdentifierEXT *out)
25006 {
25007     if (!in) return;
25008
25009     out->sType = in->sType;
25010     out->pNext = NULL;
25011     if (in->pNext)
25012         FIXME("Unexpected pNext\n");
25013 }
25014
25015 static inline void convert_VkShaderModuleIdentifierEXT_host_to_win32(const VkShaderModuleIdentifierEXT *in, VkShaderModuleIdentifierEXT32 *out)
25016 {
25017     if (!in) return;
25018
25019     out->identifierSize = in->identifierSize;
25020     memcpy(out->identifier, in->identifier, VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT * sizeof(uint8_t));
25021 }
25022
25023 static inline void convert_VkInitializePerformanceApiInfoINTEL_win32_to_host(const VkInitializePerformanceApiInfoINTEL32 *in, VkInitializePerformanceApiInfoINTEL *out)
25024 {
25025     if (!in) return;
25026
25027     out->sType = in->sType;
25028     out->pNext = NULL;
25029     out->pUserData = (void *)UlongToPtr(in->pUserData);
25030     if (in->pNext)
25031         FIXME("Unexpected pNext\n");
25032 }
25033
25034 static inline void convert_VkMemoryMapInfoKHR_win32_to_unwrapped_host(const VkMemoryMapInfoKHR32 *in, VkMemoryMapInfoKHR *out)
25035 {
25036     if (!in) return;
25037
25038     out->sType = in->sType;
25039     out->pNext = NULL;
25040     out->flags = in->flags;
25041     out->memory = in->memory;
25042     out->offset = in->offset;
25043     out->size = in->size;
25044     if (in->pNext)
25045         FIXME("Unexpected pNext\n");
25046 }
25047
25048 #ifdef _WIN64
25049 static inline void convert_VkSparseMemoryBind_win64_to_host(const VkSparseMemoryBind *in, VkSparseMemoryBind *out)
25050 {
25051     if (!in) return;
25052
25053     out->resourceOffset = in->resourceOffset;
25054     out->size = in->size;
25055     out->memory = in->memory ? wine_device_memory_from_handle(in->memory)->memory : 0;
25056     out->memoryOffset = in->memoryOffset;
25057     out->flags = in->flags;
25058 }
25059 #endif /* _WIN64 */
25060
25061 static inline void convert_VkSparseMemoryBind_win32_to_host(const VkSparseMemoryBind32 *in, VkSparseMemoryBind *out)
25062 {
25063     if (!in) return;
25064
25065     out->resourceOffset = in->resourceOffset;
25066     out->size = in->size;
25067     out->memory = in->memory ? wine_device_memory_from_handle(in->memory)->memory : 0;
25068     out->memoryOffset = in->memoryOffset;
25069     out->flags = in->flags;
25070 }
25071
25072 #ifdef _WIN64
25073 static inline const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win64_to_host(struct conversion_context *ctx, const VkSparseMemoryBind *in, uint32_t count)
25074 {
25075     VkSparseMemoryBind *out;
25076     unsigned int i;
25077
25078     if (!in || !count) return NULL;
25079
25080     out = conversion_context_alloc(ctx, count * sizeof(*out));
25081     for (i = 0; i < count; i++)
25082     {
25083         convert_VkSparseMemoryBind_win64_to_host(&in[i], &out[i]);
25084     }
25085
25086     return out;
25087 }
25088 #endif /* _WIN64 */
25089
25090 static inline const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseMemoryBind32 *in, uint32_t count)
25091 {
25092     VkSparseMemoryBind *out;
25093     unsigned int i;
25094
25095     if (!in || !count) return NULL;
25096
25097     out = conversion_context_alloc(ctx, count * sizeof(*out));
25098     for (i = 0; i < count; i++)
25099     {
25100         convert_VkSparseMemoryBind_win32_to_host(&in[i], &out[i]);
25101     }
25102
25103     return out;
25104 }
25105
25106 #ifdef _WIN64
25107 static inline void convert_VkSparseBufferMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo *in, VkSparseBufferMemoryBindInfo *out)
25108 {
25109     if (!in) return;
25110
25111     out->buffer = in->buffer;
25112     out->bindCount = in->bindCount;
25113     out->pBinds = convert_VkSparseMemoryBind_array_win64_to_host(ctx, in->pBinds, in->bindCount);
25114 }
25115 #endif /* _WIN64 */
25116
25117 static inline void convert_VkSparseBufferMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, VkSparseBufferMemoryBindInfo *out)
25118 {
25119     if (!in) return;
25120
25121     out->buffer = in->buffer;
25122     out->bindCount = in->bindCount;
25123     out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, (const VkSparseMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
25124 }
25125
25126 #ifdef _WIN64
25127 static inline const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo *in, uint32_t count)
25128 {
25129     VkSparseBufferMemoryBindInfo *out;
25130     unsigned int i;
25131
25132     if (!in || !count) return NULL;
25133
25134     out = conversion_context_alloc(ctx, count * sizeof(*out));
25135     for (i = 0; i < count; i++)
25136     {
25137         convert_VkSparseBufferMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]);
25138     }
25139
25140     return out;
25141 }
25142 #endif /* _WIN64 */
25143
25144 static inline const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, uint32_t count)
25145 {
25146     VkSparseBufferMemoryBindInfo *out;
25147     unsigned int i;
25148
25149     if (!in || !count) return NULL;
25150
25151     out = conversion_context_alloc(ctx, count * sizeof(*out));
25152     for (i = 0; i < count; i++)
25153     {
25154         convert_VkSparseBufferMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
25155     }
25156
25157     return out;
25158 }
25159
25160 #ifdef _WIN64
25161 static inline void convert_VkSparseImageOpaqueMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo *in, VkSparseImageOpaqueMemoryBindInfo *out)
25162 {
25163     if (!in) return;
25164
25165     out->image = in->image;
25166     out->bindCount = in->bindCount;
25167     out->pBinds = convert_VkSparseMemoryBind_array_win64_to_host(ctx, in->pBinds, in->bindCount);
25168 }
25169 #endif /* _WIN64 */
25170
25171 static inline void convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, VkSparseImageOpaqueMemoryBindInfo *out)
25172 {
25173     if (!in) return;
25174
25175     out->image = in->image;
25176     out->bindCount = in->bindCount;
25177     out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, (const VkSparseMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
25178 }
25179
25180 #ifdef _WIN64
25181 static inline const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaqueMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo *in, uint32_t count)
25182 {
25183     VkSparseImageOpaqueMemoryBindInfo *out;
25184     unsigned int i;
25185
25186     if (!in || !count) return NULL;
25187
25188     out = conversion_context_alloc(ctx, count * sizeof(*out));
25189     for (i = 0; i < count; i++)
25190     {
25191         convert_VkSparseImageOpaqueMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]);
25192     }
25193
25194     return out;
25195 }
25196 #endif /* _WIN64 */
25197
25198 static inline const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, uint32_t count)
25199 {
25200     VkSparseImageOpaqueMemoryBindInfo *out;
25201     unsigned int i;
25202
25203     if (!in || !count) return NULL;
25204
25205     out = conversion_context_alloc(ctx, count * sizeof(*out));
25206     for (i = 0; i < count; i++)
25207     {
25208         convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
25209     }
25210
25211     return out;
25212 }
25213
25214 #ifdef _WIN64
25215 static inline void convert_VkSparseImageMemoryBind_win64_to_host(const VkSparseImageMemoryBind *in, VkSparseImageMemoryBind *out)
25216 {
25217     if (!in) return;
25218
25219     out->subresource = in->subresource;
25220     out->offset = in->offset;
25221     out->extent = in->extent;
25222     out->memory = in->memory ? wine_device_memory_from_handle(in->memory)->memory : 0;
25223     out->memoryOffset = in->memoryOffset;
25224     out->flags = in->flags;
25225 }
25226 #endif /* _WIN64 */
25227
25228 static inline void convert_VkSparseImageMemoryBind_win32_to_host(const VkSparseImageMemoryBind32 *in, VkSparseImageMemoryBind *out)
25229 {
25230     if (!in) return;
25231
25232     out->subresource = in->subresource;
25233     out->offset = in->offset;
25234     out->extent = in->extent;
25235     out->memory = in->memory ? wine_device_memory_from_handle(in->memory)->memory : 0;
25236     out->memoryOffset = in->memoryOffset;
25237     out->flags = in->flags;
25238 }
25239
25240 #ifdef _WIN64
25241 static inline const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBind *in, uint32_t count)
25242 {
25243     VkSparseImageMemoryBind *out;
25244     unsigned int i;
25245
25246     if (!in || !count) return NULL;
25247
25248     out = conversion_context_alloc(ctx, count * sizeof(*out));
25249     for (i = 0; i < count; i++)
25250     {
25251         convert_VkSparseImageMemoryBind_win64_to_host(&in[i], &out[i]);
25252     }
25253
25254     return out;
25255 }
25256 #endif /* _WIN64 */
25257
25258 static inline const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBind32 *in, uint32_t count)
25259 {
25260     VkSparseImageMemoryBind *out;
25261     unsigned int i;
25262
25263     if (!in || !count) return NULL;
25264
25265     out = conversion_context_alloc(ctx, count * sizeof(*out));
25266     for (i = 0; i < count; i++)
25267     {
25268         convert_VkSparseImageMemoryBind_win32_to_host(&in[i], &out[i]);
25269     }
25270
25271     return out;
25272 }
25273
25274 #ifdef _WIN64
25275 static inline void convert_VkSparseImageMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo *in, VkSparseImageMemoryBindInfo *out)
25276 {
25277     if (!in) return;
25278
25279     out->image = in->image;
25280     out->bindCount = in->bindCount;
25281     out->pBinds = convert_VkSparseImageMemoryBind_array_win64_to_host(ctx, in->pBinds, in->bindCount);
25282 }
25283 #endif /* _WIN64 */
25284
25285 static inline void convert_VkSparseImageMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, VkSparseImageMemoryBindInfo *out)
25286 {
25287     if (!in) return;
25288
25289     out->image = in->image;
25290     out->bindCount = in->bindCount;
25291     out->pBinds = convert_VkSparseImageMemoryBind_array_win32_to_host(ctx, (const VkSparseImageMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
25292 }
25293
25294 #ifdef _WIN64
25295 static inline const VkSparseImageMemoryBindInfo *convert_VkSparseImageMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo *in, uint32_t count)
25296 {
25297     VkSparseImageMemoryBindInfo *out;
25298     unsigned int i;
25299
25300     if (!in || !count) return NULL;
25301
25302     out = conversion_context_alloc(ctx, count * sizeof(*out));
25303     for (i = 0; i < count; i++)
25304     {
25305         convert_VkSparseImageMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]);
25306     }
25307
25308     return out;
25309 }
25310 #endif /* _WIN64 */
25311
25312 static inline const VkSparseImageMemoryBindInfo *convert_VkSparseImageMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, uint32_t count)
25313 {
25314     VkSparseImageMemoryBindInfo *out;
25315     unsigned int i;
25316
25317     if (!in || !count) return NULL;
25318
25319     out = conversion_context_alloc(ctx, count * sizeof(*out));
25320     for (i = 0; i < count; i++)
25321     {
25322         convert_VkSparseImageMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
25323     }
25324
25325     return out;
25326 }
25327
25328 #ifdef _WIN64
25329 static inline void convert_VkBindSparseInfo_win64_to_host(struct conversion_context *ctx, const VkBindSparseInfo *in, VkBindSparseInfo *out)
25330 {
25331     if (!in) return;
25332
25333     out->sType = in->sType;
25334     out->pNext = in->pNext;
25335     out->waitSemaphoreCount = in->waitSemaphoreCount;
25336     out->pWaitSemaphores = in->pWaitSemaphores;
25337     out->bufferBindCount = in->bufferBindCount;
25338     out->pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win64_to_host(ctx, in->pBufferBinds, in->bufferBindCount);
25339     out->imageOpaqueBindCount = in->imageOpaqueBindCount;
25340     out->pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win64_to_host(ctx, in->pImageOpaqueBinds, in->imageOpaqueBindCount);
25341     out->imageBindCount = in->imageBindCount;
25342     out->pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win64_to_host(ctx, in->pImageBinds, in->imageBindCount);
25343     out->signalSemaphoreCount = in->signalSemaphoreCount;
25344     out->pSignalSemaphores = in->pSignalSemaphores;
25345 }
25346 #endif /* _WIN64 */
25347
25348 static inline void convert_VkBindSparseInfo_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, VkBindSparseInfo *out)
25349 {
25350     const VkBaseInStructure32 *in_header;
25351     VkBaseOutStructure *out_header = (void *)out;
25352
25353     if (!in) return;
25354
25355     out->sType = in->sType;
25356     out->pNext = NULL;
25357     out->waitSemaphoreCount = in->waitSemaphoreCount;
25358     out->pWaitSemaphores = (const VkSemaphore *)UlongToPtr(in->pWaitSemaphores);
25359     out->bufferBindCount = in->bufferBindCount;
25360     out->pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(ctx, (const VkSparseBufferMemoryBindInfo32 *)UlongToPtr(in->pBufferBinds), in->bufferBindCount);
25361     out->imageOpaqueBindCount = in->imageOpaqueBindCount;
25362     out->pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(ctx, (const VkSparseImageOpaqueMemoryBindInfo32 *)UlongToPtr(in->pImageOpaqueBinds), in->imageOpaqueBindCount);
25363     out->imageBindCount = in->imageBindCount;
25364     out->pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win32_to_host(ctx, (const VkSparseImageMemoryBindInfo32 *)UlongToPtr(in->pImageBinds), in->imageBindCount);
25365     out->signalSemaphoreCount = in->signalSemaphoreCount;
25366     out->pSignalSemaphores = (const VkSemaphore *)UlongToPtr(in->pSignalSemaphores);
25367
25368     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
25369     {
25370         switch (in_header->sType)
25371         {
25372         case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
25373         {
25374             VkDeviceGroupBindSparseInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25375             const VkDeviceGroupBindSparseInfo32 *in_ext = (const VkDeviceGroupBindSparseInfo32 *)in_header;
25376             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO;
25377             out_ext->pNext = NULL;
25378             out_ext->resourceDeviceIndex = in_ext->resourceDeviceIndex;
25379             out_ext->memoryDeviceIndex = in_ext->memoryDeviceIndex;
25380             out_header->pNext = (void *)out_ext;
25381             out_header = (void *)out_ext;
25382             break;
25383         }
25384         case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
25385         {
25386             VkTimelineSemaphoreSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25387             const VkTimelineSemaphoreSubmitInfo32 *in_ext = (const VkTimelineSemaphoreSubmitInfo32 *)in_header;
25388             out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
25389             out_ext->pNext = NULL;
25390             out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount;
25391             out_ext->pWaitSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pWaitSemaphoreValues);
25392             out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount;
25393             out_ext->pSignalSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pSignalSemaphoreValues);
25394             out_header->pNext = (void *)out_ext;
25395             out_header = (void *)out_ext;
25396             break;
25397         }
25398         default:
25399             FIXME("Unhandled sType %u.\n", in_header->sType);
25400             break;
25401         }
25402     }
25403 }
25404
25405 #ifdef _WIN64
25406 static inline const VkBindSparseInfo *convert_VkBindSparseInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindSparseInfo *in, uint32_t count)
25407 {
25408     VkBindSparseInfo *out;
25409     unsigned int i;
25410
25411     if (!in || !count) return NULL;
25412
25413     out = conversion_context_alloc(ctx, count * sizeof(*out));
25414     for (i = 0; i < count; i++)
25415     {
25416         convert_VkBindSparseInfo_win64_to_host(ctx, &in[i], &out[i]);
25417     }
25418
25419     return out;
25420 }
25421 #endif /* _WIN64 */
25422
25423 static inline const VkBindSparseInfo *convert_VkBindSparseInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, uint32_t count)
25424 {
25425     VkBindSparseInfo *out;
25426     unsigned int i;
25427
25428     if (!in || !count) return NULL;
25429
25430     out = conversion_context_alloc(ctx, count * sizeof(*out));
25431     for (i = 0; i < count; i++)
25432     {
25433         convert_VkBindSparseInfo_win32_to_host(ctx, &in[i], &out[i]);
25434     }
25435
25436     return out;
25437 }
25438
25439 static inline void convert_VkPresentRegionKHR_win32_to_host(const VkPresentRegionKHR32 *in, VkPresentRegionKHR *out)
25440 {
25441     if (!in) return;
25442
25443     out->rectangleCount = in->rectangleCount;
25444     out->pRectangles = (const VkRectLayerKHR *)UlongToPtr(in->pRectangles);
25445 }
25446
25447 static inline const VkPresentRegionKHR *convert_VkPresentRegionKHR_array_win32_to_host(struct conversion_context *ctx, const VkPresentRegionKHR32 *in, uint32_t count)
25448 {
25449     VkPresentRegionKHR *out;
25450     unsigned int i;
25451
25452     if (!in || !count) return NULL;
25453
25454     out = conversion_context_alloc(ctx, count * sizeof(*out));
25455     for (i = 0; i < count; i++)
25456     {
25457         convert_VkPresentRegionKHR_win32_to_host(&in[i], &out[i]);
25458     }
25459
25460     return out;
25461 }
25462
25463 static inline void convert_VkPresentInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPresentInfoKHR32 *in, VkPresentInfoKHR *out)
25464 {
25465     const VkBaseInStructure32 *in_header;
25466     VkBaseOutStructure *out_header = (void *)out;
25467
25468     if (!in) return;
25469
25470     out->sType = in->sType;
25471     out->pNext = NULL;
25472     out->waitSemaphoreCount = in->waitSemaphoreCount;
25473     out->pWaitSemaphores = (const VkSemaphore *)UlongToPtr(in->pWaitSemaphores);
25474     out->swapchainCount = in->swapchainCount;
25475     out->pSwapchains = (const VkSwapchainKHR *)UlongToPtr(in->pSwapchains);
25476     out->pImageIndices = (const uint32_t *)UlongToPtr(in->pImageIndices);
25477     out->pResults = (VkResult *)UlongToPtr(in->pResults);
25478
25479     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
25480     {
25481         switch (in_header->sType)
25482         {
25483         case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
25484         {
25485             VkPresentRegionsKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25486             const VkPresentRegionsKHR32 *in_ext = (const VkPresentRegionsKHR32 *)in_header;
25487             out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR;
25488             out_ext->pNext = NULL;
25489             out_ext->swapchainCount = in_ext->swapchainCount;
25490             out_ext->pRegions = convert_VkPresentRegionKHR_array_win32_to_host(ctx, (const VkPresentRegionKHR32 *)UlongToPtr(in_ext->pRegions), in_ext->swapchainCount);
25491             out_header->pNext = (void *)out_ext;
25492             out_header = (void *)out_ext;
25493             break;
25494         }
25495         case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
25496         {
25497             VkDeviceGroupPresentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25498             const VkDeviceGroupPresentInfoKHR32 *in_ext = (const VkDeviceGroupPresentInfoKHR32 *)in_header;
25499             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR;
25500             out_ext->pNext = NULL;
25501             out_ext->swapchainCount = in_ext->swapchainCount;
25502             out_ext->pDeviceMasks = (const uint32_t *)UlongToPtr(in_ext->pDeviceMasks);
25503             out_ext->mode = in_ext->mode;
25504             out_header->pNext = (void *)out_ext;
25505             out_header = (void *)out_ext;
25506             break;
25507         }
25508         case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
25509         {
25510             VkPresentIdKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25511             const VkPresentIdKHR32 *in_ext = (const VkPresentIdKHR32 *)in_header;
25512             out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_ID_KHR;
25513             out_ext->pNext = NULL;
25514             out_ext->swapchainCount = in_ext->swapchainCount;
25515             out_ext->pPresentIds = (const uint64_t *)UlongToPtr(in_ext->pPresentIds);
25516             out_header->pNext = (void *)out_ext;
25517             out_header = (void *)out_ext;
25518             break;
25519         }
25520         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT:
25521         {
25522             VkSwapchainPresentFenceInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25523             const VkSwapchainPresentFenceInfoEXT32 *in_ext = (const VkSwapchainPresentFenceInfoEXT32 *)in_header;
25524             out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT;
25525             out_ext->pNext = NULL;
25526             out_ext->swapchainCount = in_ext->swapchainCount;
25527             out_ext->pFences = (const VkFence *)UlongToPtr(in_ext->pFences);
25528             out_header->pNext = (void *)out_ext;
25529             out_header = (void *)out_ext;
25530             break;
25531         }
25532         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT:
25533         {
25534             VkSwapchainPresentModeInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25535             const VkSwapchainPresentModeInfoEXT32 *in_ext = (const VkSwapchainPresentModeInfoEXT32 *)in_header;
25536             out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT;
25537             out_ext->pNext = NULL;
25538             out_ext->swapchainCount = in_ext->swapchainCount;
25539             out_ext->pPresentModes = (const VkPresentModeKHR *)UlongToPtr(in_ext->pPresentModes);
25540             out_header->pNext = (void *)out_ext;
25541             out_header = (void *)out_ext;
25542             break;
25543         }
25544         default:
25545             FIXME("Unhandled sType %u.\n", in_header->sType);
25546             break;
25547         }
25548     }
25549 }
25550
25551 #ifdef _WIN64
25552 static inline void convert_VkSubmitInfo_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, VkSubmitInfo *out)
25553 {
25554     if (!in) return;
25555
25556     out->sType = in->sType;
25557     out->pNext = in->pNext;
25558     out->waitSemaphoreCount = in->waitSemaphoreCount;
25559     out->pWaitSemaphores = in->pWaitSemaphores;
25560     out->pWaitDstStageMask = in->pWaitDstStageMask;
25561     out->commandBufferCount = in->commandBufferCount;
25562     out->pCommandBuffers = convert_VkCommandBuffer_array_win64_to_host(ctx, in->pCommandBuffers, in->commandBufferCount);
25563     out->signalSemaphoreCount = in->signalSemaphoreCount;
25564     out->pSignalSemaphores = in->pSignalSemaphores;
25565 }
25566 #endif /* _WIN64 */
25567
25568 static inline void convert_VkSubmitInfo_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo32 *in, VkSubmitInfo *out)
25569 {
25570     const VkBaseInStructure32 *in_header;
25571     VkBaseOutStructure *out_header = (void *)out;
25572
25573     if (!in) return;
25574
25575     out->sType = in->sType;
25576     out->pNext = NULL;
25577     out->waitSemaphoreCount = in->waitSemaphoreCount;
25578     out->pWaitSemaphores = (const VkSemaphore *)UlongToPtr(in->pWaitSemaphores);
25579     out->pWaitDstStageMask = (const VkPipelineStageFlags *)UlongToPtr(in->pWaitDstStageMask);
25580     out->commandBufferCount = in->commandBufferCount;
25581     out->pCommandBuffers = convert_VkCommandBuffer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->pCommandBuffers), in->commandBufferCount);
25582     out->signalSemaphoreCount = in->signalSemaphoreCount;
25583     out->pSignalSemaphores = (const VkSemaphore *)UlongToPtr(in->pSignalSemaphores);
25584
25585     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
25586     {
25587         switch (in_header->sType)
25588         {
25589         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
25590         {
25591             VkDeviceGroupSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25592             const VkDeviceGroupSubmitInfo32 *in_ext = (const VkDeviceGroupSubmitInfo32 *)in_header;
25593             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO;
25594             out_ext->pNext = NULL;
25595             out_ext->waitSemaphoreCount = in_ext->waitSemaphoreCount;
25596             out_ext->pWaitSemaphoreDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pWaitSemaphoreDeviceIndices);
25597             out_ext->commandBufferCount = in_ext->commandBufferCount;
25598             out_ext->pCommandBufferDeviceMasks = (const uint32_t *)UlongToPtr(in_ext->pCommandBufferDeviceMasks);
25599             out_ext->signalSemaphoreCount = in_ext->signalSemaphoreCount;
25600             out_ext->pSignalSemaphoreDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pSignalSemaphoreDeviceIndices);
25601             out_header->pNext = (void *)out_ext;
25602             out_header = (void *)out_ext;
25603             break;
25604         }
25605         case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
25606         {
25607             VkProtectedSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25608             const VkProtectedSubmitInfo32 *in_ext = (const VkProtectedSubmitInfo32 *)in_header;
25609             out_ext->sType = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO;
25610             out_ext->pNext = NULL;
25611             out_ext->protectedSubmit = in_ext->protectedSubmit;
25612             out_header->pNext = (void *)out_ext;
25613             out_header = (void *)out_ext;
25614             break;
25615         }
25616         case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
25617         {
25618             VkTimelineSemaphoreSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25619             const VkTimelineSemaphoreSubmitInfo32 *in_ext = (const VkTimelineSemaphoreSubmitInfo32 *)in_header;
25620             out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
25621             out_ext->pNext = NULL;
25622             out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount;
25623             out_ext->pWaitSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pWaitSemaphoreValues);
25624             out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount;
25625             out_ext->pSignalSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pSignalSemaphoreValues);
25626             out_header->pNext = (void *)out_ext;
25627             out_header = (void *)out_ext;
25628             break;
25629         }
25630         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
25631         {
25632             VkPerformanceQuerySubmitInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25633             const VkPerformanceQuerySubmitInfoKHR32 *in_ext = (const VkPerformanceQuerySubmitInfoKHR32 *)in_header;
25634             out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR;
25635             out_ext->pNext = NULL;
25636             out_ext->counterPassIndex = in_ext->counterPassIndex;
25637             out_header->pNext = (void *)out_ext;
25638             out_header = (void *)out_ext;
25639             break;
25640         }
25641         default:
25642             FIXME("Unhandled sType %u.\n", in_header->sType);
25643             break;
25644         }
25645     }
25646 }
25647
25648 #ifdef _WIN64
25649 static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, uint32_t count)
25650 {
25651     VkSubmitInfo *out;
25652     unsigned int i;
25653
25654     if (!in || !count) return NULL;
25655
25656     out = conversion_context_alloc(ctx, count * sizeof(*out));
25657     for (i = 0; i < count; i++)
25658     {
25659         convert_VkSubmitInfo_win64_to_host(ctx, &in[i], &out[i]);
25660     }
25661
25662     return out;
25663 }
25664 #endif /* _WIN64 */
25665
25666 static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo32 *in, uint32_t count)
25667 {
25668     VkSubmitInfo *out;
25669     unsigned int i;
25670
25671     if (!in || !count) return NULL;
25672
25673     out = conversion_context_alloc(ctx, count * sizeof(*out));
25674     for (i = 0; i < count; i++)
25675     {
25676         convert_VkSubmitInfo_win32_to_host(ctx, &in[i], &out[i]);
25677     }
25678
25679     return out;
25680 }
25681
25682 static inline void convert_VkSemaphoreSubmitInfo_win32_to_host(const VkSemaphoreSubmitInfo32 *in, VkSemaphoreSubmitInfo *out)
25683 {
25684     if (!in) return;
25685
25686     out->sType = in->sType;
25687     out->pNext = NULL;
25688     out->semaphore = in->semaphore;
25689     out->value = in->value;
25690     out->stageMask = in->stageMask;
25691     out->deviceIndex = in->deviceIndex;
25692     if (in->pNext)
25693         FIXME("Unexpected pNext\n");
25694 }
25695
25696 static inline const VkSemaphoreSubmitInfo *convert_VkSemaphoreSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSemaphoreSubmitInfo32 *in, uint32_t count)
25697 {
25698     VkSemaphoreSubmitInfo *out;
25699     unsigned int i;
25700
25701     if (!in || !count) return NULL;
25702
25703     out = conversion_context_alloc(ctx, count * sizeof(*out));
25704     for (i = 0; i < count; i++)
25705     {
25706         convert_VkSemaphoreSubmitInfo_win32_to_host(&in[i], &out[i]);
25707     }
25708
25709     return out;
25710 }
25711
25712 #ifdef _WIN64
25713 static inline void convert_VkCommandBufferSubmitInfo_win64_to_host(const VkCommandBufferSubmitInfo *in, VkCommandBufferSubmitInfo *out)
25714 {
25715     if (!in) return;
25716
25717     out->sType = in->sType;
25718     out->pNext = in->pNext;
25719     out->commandBuffer = wine_cmd_buffer_from_handle(in->commandBuffer)->command_buffer;
25720     out->deviceMask = in->deviceMask;
25721 }
25722 #endif /* _WIN64 */
25723
25724 static inline void convert_VkCommandBufferSubmitInfo_win32_to_host(const VkCommandBufferSubmitInfo32 *in, VkCommandBufferSubmitInfo *out)
25725 {
25726     if (!in) return;
25727
25728     out->sType = in->sType;
25729     out->pNext = NULL;
25730     out->commandBuffer = wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(in->commandBuffer))->command_buffer;
25731     out->deviceMask = in->deviceMask;
25732     if (in->pNext)
25733         FIXME("Unexpected pNext\n");
25734 }
25735
25736 #ifdef _WIN64
25737 static inline const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo *in, uint32_t count)
25738 {
25739     VkCommandBufferSubmitInfo *out;
25740     unsigned int i;
25741
25742     if (!in || !count) return NULL;
25743
25744     out = conversion_context_alloc(ctx, count * sizeof(*out));
25745     for (i = 0; i < count; i++)
25746     {
25747         convert_VkCommandBufferSubmitInfo_win64_to_host(&in[i], &out[i]);
25748     }
25749
25750     return out;
25751 }
25752 #endif /* _WIN64 */
25753
25754 static inline const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo32 *in, uint32_t count)
25755 {
25756     VkCommandBufferSubmitInfo *out;
25757     unsigned int i;
25758
25759     if (!in || !count) return NULL;
25760
25761     out = conversion_context_alloc(ctx, count * sizeof(*out));
25762     for (i = 0; i < count; i++)
25763     {
25764         convert_VkCommandBufferSubmitInfo_win32_to_host(&in[i], &out[i]);
25765     }
25766
25767     return out;
25768 }
25769
25770 #ifdef _WIN64
25771 static inline void convert_VkSubmitInfo2_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, VkSubmitInfo2 *out)
25772 {
25773     if (!in) return;
25774
25775     out->sType = in->sType;
25776     out->pNext = in->pNext;
25777     out->flags = in->flags;
25778     out->waitSemaphoreInfoCount = in->waitSemaphoreInfoCount;
25779     out->pWaitSemaphoreInfos = in->pWaitSemaphoreInfos;
25780     out->commandBufferInfoCount = in->commandBufferInfoCount;
25781     out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win64_to_host(ctx, in->pCommandBufferInfos, in->commandBufferInfoCount);
25782     out->signalSemaphoreInfoCount = in->signalSemaphoreInfoCount;
25783     out->pSignalSemaphoreInfos = in->pSignalSemaphoreInfos;
25784 }
25785 #endif /* _WIN64 */
25786
25787 static inline void convert_VkSubmitInfo2_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, VkSubmitInfo2 *out)
25788 {
25789     const VkBaseInStructure32 *in_header;
25790     VkBaseOutStructure *out_header = (void *)out;
25791
25792     if (!in) return;
25793
25794     out->sType = in->sType;
25795     out->pNext = NULL;
25796     out->flags = in->flags;
25797     out->waitSemaphoreInfoCount = in->waitSemaphoreInfoCount;
25798     out->pWaitSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, (const VkSemaphoreSubmitInfo32 *)UlongToPtr(in->pWaitSemaphoreInfos), in->waitSemaphoreInfoCount);
25799     out->commandBufferInfoCount = in->commandBufferInfoCount;
25800     out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win32_to_host(ctx, (const VkCommandBufferSubmitInfo32 *)UlongToPtr(in->pCommandBufferInfos), in->commandBufferInfoCount);
25801     out->signalSemaphoreInfoCount = in->signalSemaphoreInfoCount;
25802     out->pSignalSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, (const VkSemaphoreSubmitInfo32 *)UlongToPtr(in->pSignalSemaphoreInfos), in->signalSemaphoreInfoCount);
25803
25804     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
25805     {
25806         switch (in_header->sType)
25807         {
25808         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
25809         {
25810             VkPerformanceQuerySubmitInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25811             const VkPerformanceQuerySubmitInfoKHR32 *in_ext = (const VkPerformanceQuerySubmitInfoKHR32 *)in_header;
25812             out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR;
25813             out_ext->pNext = NULL;
25814             out_ext->counterPassIndex = in_ext->counterPassIndex;
25815             out_header->pNext = (void *)out_ext;
25816             out_header = (void *)out_ext;
25817             break;
25818         }
25819         default:
25820             FIXME("Unhandled sType %u.\n", in_header->sType);
25821             break;
25822         }
25823     }
25824 }
25825
25826 #ifdef _WIN64
25827 static inline const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, uint32_t count)
25828 {
25829     VkSubmitInfo2 *out;
25830     unsigned int i;
25831
25832     if (!in || !count) return NULL;
25833
25834     out = conversion_context_alloc(ctx, count * sizeof(*out));
25835     for (i = 0; i < count; i++)
25836     {
25837         convert_VkSubmitInfo2_win64_to_host(ctx, &in[i], &out[i]);
25838     }
25839
25840     return out;
25841 }
25842 #endif /* _WIN64 */
25843
25844 static inline const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, uint32_t count)
25845 {
25846     VkSubmitInfo2 *out;
25847     unsigned int i;
25848
25849     if (!in || !count) return NULL;
25850
25851     out = conversion_context_alloc(ctx, count * sizeof(*out));
25852     for (i = 0; i < count; i++)
25853     {
25854         convert_VkSubmitInfo2_win32_to_host(ctx, &in[i], &out[i]);
25855     }
25856
25857     return out;
25858 }
25859
25860 static inline void convert_VkReleaseSwapchainImagesInfoEXT_win32_to_host(const VkReleaseSwapchainImagesInfoEXT32 *in, VkReleaseSwapchainImagesInfoEXT *out)
25861 {
25862     if (!in) return;
25863
25864     out->sType = in->sType;
25865     out->pNext = NULL;
25866     out->swapchain = in->swapchain;
25867     out->imageIndexCount = in->imageIndexCount;
25868     out->pImageIndices = (const uint32_t *)UlongToPtr(in->pImageIndices);
25869     if (in->pNext)
25870         FIXME("Unexpected pNext\n");
25871 }
25872
25873 #ifdef _WIN64
25874 static inline void convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(const VkDebugUtilsObjectNameInfoEXT *in, VkDebugUtilsObjectNameInfoEXT *out)
25875 {
25876     if (!in) return;
25877
25878     out->sType = in->sType;
25879     out->pNext = in->pNext;
25880     out->objectType = in->objectType;
25881     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
25882     out->pObjectName = in->pObjectName;
25883 }
25884 #endif /* _WIN64 */
25885
25886 static inline void convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(const VkDebugUtilsObjectNameInfoEXT32 *in, VkDebugUtilsObjectNameInfoEXT *out)
25887 {
25888     if (!in) return;
25889
25890     out->sType = in->sType;
25891     out->pNext = NULL;
25892     out->objectType = in->objectType;
25893     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
25894     out->pObjectName = (const char *)UlongToPtr(in->pObjectName);
25895     if (in->pNext)
25896         FIXME("Unexpected pNext\n");
25897 }
25898
25899 #ifdef _WIN64
25900 static inline void convert_VkDebugUtilsObjectTagInfoEXT_win64_to_host(const VkDebugUtilsObjectTagInfoEXT *in, VkDebugUtilsObjectTagInfoEXT *out)
25901 {
25902     if (!in) return;
25903
25904     out->sType = in->sType;
25905     out->pNext = in->pNext;
25906     out->objectType = in->objectType;
25907     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
25908     out->tagName = in->tagName;
25909     out->tagSize = in->tagSize;
25910     out->pTag = in->pTag;
25911 }
25912 #endif /* _WIN64 */
25913
25914 static inline void convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host(const VkDebugUtilsObjectTagInfoEXT32 *in, VkDebugUtilsObjectTagInfoEXT *out)
25915 {
25916     if (!in) return;
25917
25918     out->sType = in->sType;
25919     out->pNext = NULL;
25920     out->objectType = in->objectType;
25921     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
25922     out->tagName = in->tagName;
25923     out->tagSize = in->tagSize;
25924     out->pTag = (const void *)UlongToPtr(in->pTag);
25925     if (in->pNext)
25926         FIXME("Unexpected pNext\n");
25927 }
25928
25929 static inline void convert_VkHdrMetadataEXT_win32_to_host(const VkHdrMetadataEXT32 *in, VkHdrMetadataEXT *out)
25930 {
25931     if (!in) return;
25932
25933     out->sType = in->sType;
25934     out->pNext = NULL;
25935     out->displayPrimaryRed = in->displayPrimaryRed;
25936     out->displayPrimaryGreen = in->displayPrimaryGreen;
25937     out->displayPrimaryBlue = in->displayPrimaryBlue;
25938     out->whitePoint = in->whitePoint;
25939     out->maxLuminance = in->maxLuminance;
25940     out->minLuminance = in->minLuminance;
25941     out->maxContentLightLevel = in->maxContentLightLevel;
25942     out->maxFrameAverageLightLevel = in->maxFrameAverageLightLevel;
25943     if (in->pNext)
25944         FIXME("Unexpected pNext\n");
25945 }
25946
25947 static inline const VkHdrMetadataEXT *convert_VkHdrMetadataEXT_array_win32_to_host(struct conversion_context *ctx, const VkHdrMetadataEXT32 *in, uint32_t count)
25948 {
25949     VkHdrMetadataEXT *out;
25950     unsigned int i;
25951
25952     if (!in || !count) return NULL;
25953
25954     out = conversion_context_alloc(ctx, count * sizeof(*out));
25955     for (i = 0; i < count; i++)
25956     {
25957         convert_VkHdrMetadataEXT_win32_to_host(&in[i], &out[i]);
25958     }
25959
25960     return out;
25961 }
25962
25963 static inline void convert_VkSemaphoreSignalInfo_win32_to_host(const VkSemaphoreSignalInfo32 *in, VkSemaphoreSignalInfo *out)
25964 {
25965     if (!in) return;
25966
25967     out->sType = in->sType;
25968     out->pNext = NULL;
25969     out->semaphore = in->semaphore;
25970     out->value = in->value;
25971     if (in->pNext)
25972         FIXME("Unexpected pNext\n");
25973 }
25974
25975 static inline const VkDebugUtilsLabelEXT *convert_VkDebugUtilsLabelEXT_array_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsLabelEXT32 *in, uint32_t count)
25976 {
25977     VkDebugUtilsLabelEXT *out;
25978     unsigned int i;
25979
25980     if (!in || !count) return NULL;
25981
25982     out = conversion_context_alloc(ctx, count * sizeof(*out));
25983     for (i = 0; i < count; i++)
25984     {
25985         convert_VkDebugUtilsLabelEXT_win32_to_host(&in[i], &out[i]);
25986     }
25987
25988     return out;
25989 }
25990
25991 #ifdef _WIN64
25992 static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT *in, uint32_t count)
25993 {
25994     VkDebugUtilsObjectNameInfoEXT *out;
25995     unsigned int i;
25996
25997     if (!in || !count) return NULL;
25998
25999     out = conversion_context_alloc(ctx, count * sizeof(*out));
26000     for (i = 0; i < count; i++)
26001     {
26002         convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(&in[i], &out[i]);
26003     }
26004
26005     return out;
26006 }
26007 #endif /* _WIN64 */
26008
26009 static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT32 *in, uint32_t count)
26010 {
26011     VkDebugUtilsObjectNameInfoEXT *out;
26012     unsigned int i;
26013
26014     if (!in || !count) return NULL;
26015
26016     out = conversion_context_alloc(ctx, count * sizeof(*out));
26017     for (i = 0; i < count; i++)
26018     {
26019         convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(&in[i], &out[i]);
26020     }
26021
26022     return out;
26023 }
26024
26025 #ifdef _WIN64
26026 static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT *in, VkDebugUtilsMessengerCallbackDataEXT *out)
26027 {
26028     if (!in) return;
26029
26030     out->sType = in->sType;
26031     out->pNext = in->pNext;
26032     out->flags = in->flags;
26033     out->pMessageIdName = in->pMessageIdName;
26034     out->messageIdNumber = in->messageIdNumber;
26035     out->pMessage = in->pMessage;
26036     out->queueLabelCount = in->queueLabelCount;
26037     out->pQueueLabels = in->pQueueLabels;
26038     out->cmdBufLabelCount = in->cmdBufLabelCount;
26039     out->pCmdBufLabels = in->pCmdBufLabels;
26040     out->objectCount = in->objectCount;
26041     out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(ctx, in->pObjects, in->objectCount);
26042 }
26043 #endif /* _WIN64 */
26044
26045 static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT32 *in, VkDebugUtilsMessengerCallbackDataEXT *out)
26046 {
26047     const VkBaseInStructure32 *in_header;
26048     VkBaseOutStructure *out_header = (void *)out;
26049
26050     if (!in) return;
26051
26052     out->sType = in->sType;
26053     out->pNext = NULL;
26054     out->flags = in->flags;
26055     out->pMessageIdName = (const char *)UlongToPtr(in->pMessageIdName);
26056     out->messageIdNumber = in->messageIdNumber;
26057     out->pMessage = (const char *)UlongToPtr(in->pMessage);
26058     out->queueLabelCount = in->queueLabelCount;
26059     out->pQueueLabels = convert_VkDebugUtilsLabelEXT_array_win32_to_host(ctx, (const VkDebugUtilsLabelEXT32 *)UlongToPtr(in->pQueueLabels), in->queueLabelCount);
26060     out->cmdBufLabelCount = in->cmdBufLabelCount;
26061     out->pCmdBufLabels = convert_VkDebugUtilsLabelEXT_array_win32_to_host(ctx, (const VkDebugUtilsLabelEXT32 *)UlongToPtr(in->pCmdBufLabels), in->cmdBufLabelCount);
26062     out->objectCount = in->objectCount;
26063     out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win32_to_host(ctx, (const VkDebugUtilsObjectNameInfoEXT32 *)UlongToPtr(in->pObjects), in->objectCount);
26064
26065     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
26066     {
26067         switch (in_header->sType)
26068         {
26069         case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT:
26070         {
26071             VkDeviceAddressBindingCallbackDataEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
26072             const VkDeviceAddressBindingCallbackDataEXT32 *in_ext = (const VkDeviceAddressBindingCallbackDataEXT32 *)in_header;
26073             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT;
26074             out_ext->pNext = NULL;
26075             out_ext->flags = in_ext->flags;
26076             out_ext->baseAddress = in_ext->baseAddress;
26077             out_ext->size = in_ext->size;
26078             out_ext->bindingType = in_ext->bindingType;
26079             out_header->pNext = (void *)out_ext;
26080             out_header = (void *)out_ext;
26081             break;
26082         }
26083         default:
26084             FIXME("Unhandled sType %u.\n", in_header->sType);
26085             break;
26086         }
26087     }
26088 }
26089
26090 static inline void convert_VkMemoryUnmapInfoKHR_win32_to_unwrapped_host(const VkMemoryUnmapInfoKHR32 *in, VkMemoryUnmapInfoKHR *out)
26091 {
26092     if (!in) return;
26093
26094     out->sType = in->sType;
26095     out->pNext = NULL;
26096     out->flags = in->flags;
26097     out->memory = in->memory;
26098     if (in->pNext)
26099         FIXME("Unexpected pNext\n");
26100 }
26101
26102 static inline void convert_VkCopyDescriptorSet_win32_to_host(const VkCopyDescriptorSet32 *in, VkCopyDescriptorSet *out)
26103 {
26104     if (!in) return;
26105
26106     out->sType = in->sType;
26107     out->pNext = NULL;
26108     out->srcSet = in->srcSet;
26109     out->srcBinding = in->srcBinding;
26110     out->srcArrayElement = in->srcArrayElement;
26111     out->dstSet = in->dstSet;
26112     out->dstBinding = in->dstBinding;
26113     out->dstArrayElement = in->dstArrayElement;
26114     out->descriptorCount = in->descriptorCount;
26115     if (in->pNext)
26116         FIXME("Unexpected pNext\n");
26117 }
26118
26119 static inline const VkCopyDescriptorSet *convert_VkCopyDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkCopyDescriptorSet32 *in, uint32_t count)
26120 {
26121     VkCopyDescriptorSet *out;
26122     unsigned int i;
26123
26124     if (!in || !count) return NULL;
26125
26126     out = conversion_context_alloc(ctx, count * sizeof(*out));
26127     for (i = 0; i < count; i++)
26128     {
26129         convert_VkCopyDescriptorSet_win32_to_host(&in[i], &out[i]);
26130     }
26131
26132     return out;
26133 }
26134
26135 static inline void convert_VkSemaphoreWaitInfo_win32_to_host(const VkSemaphoreWaitInfo32 *in, VkSemaphoreWaitInfo *out)
26136 {
26137     if (!in) return;
26138
26139     out->sType = in->sType;
26140     out->pNext = NULL;
26141     out->flags = in->flags;
26142     out->semaphoreCount = in->semaphoreCount;
26143     out->pSemaphores = (const VkSemaphore *)UlongToPtr(in->pSemaphores);
26144     out->pValues = (const uint64_t *)UlongToPtr(in->pValues);
26145     if (in->pNext)
26146         FIXME("Unexpected pNext\n");
26147 }
26148
26149 #ifdef _WIN64
26150 static NTSTATUS thunk64_vkAcquireNextImage2KHR(void *args)
26151 {
26152     struct vkAcquireNextImage2KHR_params *params = args;
26153
26154     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pImageIndex);
26155
26156     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImage2KHR(wine_device_from_handle(params->device)->device, params->pAcquireInfo, params->pImageIndex);
26157     return STATUS_SUCCESS;
26158 }
26159 #endif /* _WIN64 */
26160
26161 static NTSTATUS thunk32_vkAcquireNextImage2KHR(void *args)
26162 {
26163     struct
26164     {
26165         PTR32 device;
26166         PTR32 pAcquireInfo;
26167         PTR32 pImageIndex;
26168         VkResult result;
26169     } *params = args;
26170     VkAcquireNextImageInfoKHR pAcquireInfo_host;
26171
26172     TRACE("%#x, %#x, %#x\n", params->device, params->pAcquireInfo, params->pImageIndex);
26173
26174     convert_VkAcquireNextImageInfoKHR_win32_to_host((const VkAcquireNextImageInfoKHR32 *)UlongToPtr(params->pAcquireInfo), &pAcquireInfo_host);
26175     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkAcquireNextImage2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pAcquireInfo_host, (uint32_t *)UlongToPtr(params->pImageIndex));
26176     return STATUS_SUCCESS;
26177 }
26178
26179 #ifdef _WIN64
26180 static NTSTATUS thunk64_vkAcquireNextImageKHR(void *args)
26181 {
26182     struct vkAcquireNextImageKHR_params *params = args;
26183
26184     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);
26185
26186     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);
26187     return STATUS_SUCCESS;
26188 }
26189 #endif /* _WIN64 */
26190
26191 static NTSTATUS thunk32_vkAcquireNextImageKHR(void *args)
26192 {
26193     struct
26194     {
26195         PTR32 device;
26196         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
26197         uint64_t DECLSPEC_ALIGN(8) timeout;
26198         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
26199         VkFence DECLSPEC_ALIGN(8) fence;
26200         PTR32 pImageIndex;
26201         VkResult result;
26202     } *params = args;
26203
26204     TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %#x\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);
26205
26206     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkAcquireNextImageKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->swapchain, params->timeout, params->semaphore, params->fence, (uint32_t *)UlongToPtr(params->pImageIndex));
26207     return STATUS_SUCCESS;
26208 }
26209
26210 #ifdef _WIN64
26211 static NTSTATUS thunk64_vkAcquirePerformanceConfigurationINTEL(void *args)
26212 {
26213     struct vkAcquirePerformanceConfigurationINTEL_params *params = args;
26214
26215     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pConfiguration);
26216
26217     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquirePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->pAcquireInfo, params->pConfiguration);
26218     return STATUS_SUCCESS;
26219 }
26220 #endif /* _WIN64 */
26221
26222 static NTSTATUS thunk32_vkAcquirePerformanceConfigurationINTEL(void *args)
26223 {
26224     struct
26225     {
26226         PTR32 device;
26227         PTR32 pAcquireInfo;
26228         PTR32 pConfiguration;
26229         VkResult result;
26230     } *params = args;
26231     VkPerformanceConfigurationAcquireInfoINTEL pAcquireInfo_host;
26232
26233     TRACE("%#x, %#x, %#x\n", params->device, params->pAcquireInfo, params->pConfiguration);
26234
26235     convert_VkPerformanceConfigurationAcquireInfoINTEL_win32_to_host((const VkPerformanceConfigurationAcquireInfoINTEL32 *)UlongToPtr(params->pAcquireInfo), &pAcquireInfo_host);
26236     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkAcquirePerformanceConfigurationINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pAcquireInfo_host, (VkPerformanceConfigurationINTEL *)UlongToPtr(params->pConfiguration));
26237     return STATUS_SUCCESS;
26238 }
26239
26240 #ifdef _WIN64
26241 static NTSTATUS thunk64_vkAcquireProfilingLockKHR(void *args)
26242 {
26243     struct vkAcquireProfilingLockKHR_params *params = args;
26244
26245     TRACE("%p, %p\n", params->device, params->pInfo);
26246
26247     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireProfilingLockKHR(wine_device_from_handle(params->device)->device, params->pInfo);
26248     return STATUS_SUCCESS;
26249 }
26250 #endif /* _WIN64 */
26251
26252 static NTSTATUS thunk32_vkAcquireProfilingLockKHR(void *args)
26253 {
26254     struct
26255     {
26256         PTR32 device;
26257         PTR32 pInfo;
26258         VkResult result;
26259     } *params = args;
26260     VkAcquireProfilingLockInfoKHR pInfo_host;
26261
26262     TRACE("%#x, %#x\n", params->device, params->pInfo);
26263
26264     convert_VkAcquireProfilingLockInfoKHR_win32_to_host((const VkAcquireProfilingLockInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
26265     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkAcquireProfilingLockKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
26266     return STATUS_SUCCESS;
26267 }
26268
26269 #ifdef _WIN64
26270 static NTSTATUS thunk64_vkAllocateCommandBuffers(void *args)
26271 {
26272     struct vkAllocateCommandBuffers_params *params = args;
26273
26274     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pCommandBuffers);
26275
26276     params->result = wine_vkAllocateCommandBuffers(params->device, params->pAllocateInfo, params->pCommandBuffers);
26277     return STATUS_SUCCESS;
26278 }
26279 #endif /* _WIN64 */
26280
26281 static NTSTATUS thunk32_vkAllocateCommandBuffers(void *args)
26282 {
26283     struct
26284     {
26285         PTR32 device;
26286         PTR32 pAllocateInfo;
26287         PTR32 pCommandBuffers;
26288         VkResult result;
26289     } *params = args;
26290     VkCommandBufferAllocateInfo pAllocateInfo_host;
26291     VkCommandBuffer *pCommandBuffers_host;
26292     struct conversion_context ctx;
26293
26294     TRACE("%#x, %#x, %#x\n", params->device, params->pAllocateInfo, params->pCommandBuffers);
26295
26296     init_conversion_context(&ctx);
26297     convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host((const VkCommandBufferAllocateInfo32 *)UlongToPtr(params->pAllocateInfo), &pAllocateInfo_host);
26298     pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_unwrapped_host(&ctx, (PTR32 *)UlongToPtr(params->pCommandBuffers), ((const VkCommandBufferAllocateInfo32 *)UlongToPtr(params->pAllocateInfo))->commandBufferCount);
26299     params->result = wine_vkAllocateCommandBuffers((VkDevice)UlongToPtr(params->device), &pAllocateInfo_host, pCommandBuffers_host);
26300     free_conversion_context(&ctx);
26301     return STATUS_SUCCESS;
26302 }
26303
26304 #ifdef _WIN64
26305 static NTSTATUS thunk64_vkAllocateDescriptorSets(void *args)
26306 {
26307     struct vkAllocateDescriptorSets_params *params = args;
26308
26309     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pDescriptorSets);
26310
26311     params->result = wine_device_from_handle(params->device)->funcs.p_vkAllocateDescriptorSets(wine_device_from_handle(params->device)->device, params->pAllocateInfo, params->pDescriptorSets);
26312     return STATUS_SUCCESS;
26313 }
26314 #endif /* _WIN64 */
26315
26316 static NTSTATUS thunk32_vkAllocateDescriptorSets(void *args)
26317 {
26318     struct
26319     {
26320         PTR32 device;
26321         PTR32 pAllocateInfo;
26322         PTR32 pDescriptorSets;
26323         VkResult result;
26324     } *params = args;
26325     VkDescriptorSetAllocateInfo pAllocateInfo_host;
26326     struct conversion_context ctx;
26327
26328     TRACE("%#x, %#x, %#x\n", params->device, params->pAllocateInfo, params->pDescriptorSets);
26329
26330     init_conversion_context(&ctx);
26331     convert_VkDescriptorSetAllocateInfo_win32_to_host(&ctx, (const VkDescriptorSetAllocateInfo32 *)UlongToPtr(params->pAllocateInfo), &pAllocateInfo_host);
26332     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkAllocateDescriptorSets(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pAllocateInfo_host, (VkDescriptorSet *)UlongToPtr(params->pDescriptorSets));
26333     free_conversion_context(&ctx);
26334     return STATUS_SUCCESS;
26335 }
26336
26337 #ifdef _WIN64
26338 static NTSTATUS thunk64_vkAllocateMemory(void *args)
26339 {
26340     struct vkAllocateMemory_params *params = args;
26341
26342     TRACE("%p, %p, %p, %p\n", params->device, params->pAllocateInfo, params->pAllocator, params->pMemory);
26343
26344     params->result = wine_vkAllocateMemory(params->device, params->pAllocateInfo, params->pAllocator, params->pMemory);
26345     return STATUS_SUCCESS;
26346 }
26347 #endif /* _WIN64 */
26348
26349 static NTSTATUS thunk32_vkAllocateMemory(void *args)
26350 {
26351     struct
26352     {
26353         PTR32 device;
26354         PTR32 pAllocateInfo;
26355         PTR32 pAllocator;
26356         PTR32 pMemory;
26357         VkResult result;
26358     } *params = args;
26359     VkMemoryAllocateInfo pAllocateInfo_host;
26360     struct conversion_context ctx;
26361
26362     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pAllocateInfo, params->pAllocator, params->pMemory);
26363
26364     init_conversion_context(&ctx);
26365     convert_VkMemoryAllocateInfo_win32_to_host(&ctx, (const VkMemoryAllocateInfo32 *)UlongToPtr(params->pAllocateInfo), &pAllocateInfo_host);
26366     params->result = wine_vkAllocateMemory((VkDevice)UlongToPtr(params->device), &pAllocateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkDeviceMemory *)UlongToPtr(params->pMemory));
26367     free_conversion_context(&ctx);
26368     return STATUS_SUCCESS;
26369 }
26370
26371 #ifdef _WIN64
26372 static NTSTATUS thunk64_vkBeginCommandBuffer(void *args)
26373 {
26374     struct vkBeginCommandBuffer_params *params = args;
26375
26376     TRACE("%p, %p\n", params->commandBuffer, params->pBeginInfo);
26377
26378     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkBeginCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBeginInfo);
26379     return STATUS_SUCCESS;
26380 }
26381 #endif /* _WIN64 */
26382
26383 static NTSTATUS thunk32_vkBeginCommandBuffer(void *args)
26384 {
26385     struct
26386     {
26387         PTR32 commandBuffer;
26388         PTR32 pBeginInfo;
26389         VkResult result;
26390     } *params = args;
26391     VkCommandBufferBeginInfo pBeginInfo_host;
26392     struct conversion_context ctx;
26393
26394     TRACE("%#x, %#x\n", params->commandBuffer, params->pBeginInfo);
26395
26396     init_conversion_context(&ctx);
26397     convert_VkCommandBufferBeginInfo_win32_to_host(&ctx, (const VkCommandBufferBeginInfo32 *)UlongToPtr(params->pBeginInfo), &pBeginInfo_host);
26398     params->result = wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkBeginCommandBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pBeginInfo_host);
26399     free_conversion_context(&ctx);
26400     return STATUS_SUCCESS;
26401 }
26402
26403 #ifdef _WIN64
26404 static NTSTATUS thunk64_vkBindAccelerationStructureMemoryNV(void *args)
26405 {
26406     struct vkBindAccelerationStructureMemoryNV_params *params = args;
26407     const VkBindAccelerationStructureMemoryInfoNV *pBindInfos_host;
26408     struct conversion_context ctx;
26409
26410     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
26411
26412     init_conversion_context(&ctx);
26413     pBindInfos_host = convert_VkBindAccelerationStructureMemoryInfoNV_array_win64_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
26414     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindAccelerationStructureMemoryNV(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
26415     free_conversion_context(&ctx);
26416     return STATUS_SUCCESS;
26417 }
26418 #endif /* _WIN64 */
26419
26420 static NTSTATUS thunk32_vkBindAccelerationStructureMemoryNV(void *args)
26421 {
26422     struct
26423     {
26424         PTR32 device;
26425         uint32_t bindInfoCount;
26426         PTR32 pBindInfos;
26427         VkResult result;
26428     } *params = args;
26429     const VkBindAccelerationStructureMemoryInfoNV *pBindInfos_host;
26430     struct conversion_context ctx;
26431
26432     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
26433
26434     init_conversion_context(&ctx);
26435     pBindInfos_host = convert_VkBindAccelerationStructureMemoryInfoNV_array_win32_to_host(&ctx, (const VkBindAccelerationStructureMemoryInfoNV32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
26436     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBindAccelerationStructureMemoryNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->bindInfoCount, pBindInfos_host);
26437     free_conversion_context(&ctx);
26438     return STATUS_SUCCESS;
26439 }
26440
26441 #ifdef _WIN64
26442 static NTSTATUS thunk64_vkBindBufferMemory(void *args)
26443 {
26444     struct vkBindBufferMemory_params *params = args;
26445
26446     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));
26447
26448     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory(wine_device_from_handle(params->device)->device, params->buffer, wine_device_memory_from_handle(params->memory)->memory, params->memoryOffset);
26449     return STATUS_SUCCESS;
26450 }
26451 #endif /* _WIN64 */
26452
26453 static NTSTATUS thunk32_vkBindBufferMemory(void *args)
26454 {
26455     struct
26456     {
26457         PTR32 device;
26458         VkBuffer DECLSPEC_ALIGN(8) buffer;
26459         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
26460         VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
26461         VkResult result;
26462     } *params = args;
26463
26464     TRACE("%#x, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->memoryOffset));
26465
26466     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBindBufferMemory(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->buffer, wine_device_memory_from_handle(params->memory)->memory, params->memoryOffset);
26467     return STATUS_SUCCESS;
26468 }
26469
26470 #ifdef _WIN64
26471 static NTSTATUS thunk64_vkBindBufferMemory2(void *args)
26472 {
26473     struct vkBindBufferMemory2_params *params = args;
26474     const VkBindBufferMemoryInfo *pBindInfos_host;
26475     struct conversion_context ctx;
26476
26477     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
26478
26479     init_conversion_context(&ctx);
26480     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win64_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
26481     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
26482     free_conversion_context(&ctx);
26483     return STATUS_SUCCESS;
26484 }
26485 #endif /* _WIN64 */
26486
26487 static NTSTATUS thunk32_vkBindBufferMemory2(void *args)
26488 {
26489     struct
26490     {
26491         PTR32 device;
26492         uint32_t bindInfoCount;
26493         PTR32 pBindInfos;
26494         VkResult result;
26495     } *params = args;
26496     const VkBindBufferMemoryInfo *pBindInfos_host;
26497     struct conversion_context ctx;
26498
26499     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
26500
26501     init_conversion_context(&ctx);
26502     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win32_to_host(&ctx, (const VkBindBufferMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
26503     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBindBufferMemory2(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->bindInfoCount, pBindInfos_host);
26504     free_conversion_context(&ctx);
26505     return STATUS_SUCCESS;
26506 }
26507
26508 #ifdef _WIN64
26509 static NTSTATUS thunk64_vkBindBufferMemory2KHR(void *args)
26510 {
26511     struct vkBindBufferMemory2KHR_params *params = args;
26512     const VkBindBufferMemoryInfo *pBindInfos_host;
26513     struct conversion_context ctx;
26514
26515     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
26516
26517     init_conversion_context(&ctx);
26518     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win64_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
26519     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
26520     free_conversion_context(&ctx);
26521     return STATUS_SUCCESS;
26522 }
26523 #endif /* _WIN64 */
26524
26525 static NTSTATUS thunk32_vkBindBufferMemory2KHR(void *args)
26526 {
26527     struct
26528     {
26529         PTR32 device;
26530         uint32_t bindInfoCount;
26531         PTR32 pBindInfos;
26532         VkResult result;
26533     } *params = args;
26534     const VkBindBufferMemoryInfo *pBindInfos_host;
26535     struct conversion_context ctx;
26536
26537     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
26538
26539     init_conversion_context(&ctx);
26540     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win32_to_host(&ctx, (const VkBindBufferMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
26541     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBindBufferMemory2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->bindInfoCount, pBindInfos_host);
26542     free_conversion_context(&ctx);
26543     return STATUS_SUCCESS;
26544 }
26545
26546 #ifdef _WIN64
26547 static NTSTATUS thunk64_vkBindImageMemory(void *args)
26548 {
26549     struct vkBindImageMemory_params *params = args;
26550
26551     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));
26552
26553     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory(wine_device_from_handle(params->device)->device, params->image, wine_device_memory_from_handle(params->memory)->memory, params->memoryOffset);
26554     return STATUS_SUCCESS;
26555 }
26556 #endif /* _WIN64 */
26557
26558 static NTSTATUS thunk32_vkBindImageMemory(void *args)
26559 {
26560     struct
26561     {
26562         PTR32 device;
26563         VkImage DECLSPEC_ALIGN(8) image;
26564         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
26565         VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
26566         VkResult result;
26567     } *params = args;
26568
26569     TRACE("%#x, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->image), wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->memoryOffset));
26570
26571     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBindImageMemory(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, wine_device_memory_from_handle(params->memory)->memory, params->memoryOffset);
26572     return STATUS_SUCCESS;
26573 }
26574
26575 #ifdef _WIN64
26576 static NTSTATUS thunk64_vkBindImageMemory2(void *args)
26577 {
26578     struct vkBindImageMemory2_params *params = args;
26579     const VkBindImageMemoryInfo *pBindInfos_host;
26580     struct conversion_context ctx;
26581
26582     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
26583
26584     init_conversion_context(&ctx);
26585     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win64_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
26586     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
26587     free_conversion_context(&ctx);
26588     return STATUS_SUCCESS;
26589 }
26590 #endif /* _WIN64 */
26591
26592 static NTSTATUS thunk32_vkBindImageMemory2(void *args)
26593 {
26594     struct
26595     {
26596         PTR32 device;
26597         uint32_t bindInfoCount;
26598         PTR32 pBindInfos;
26599         VkResult result;
26600     } *params = args;
26601     const VkBindImageMemoryInfo *pBindInfos_host;
26602     struct conversion_context ctx;
26603
26604     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
26605
26606     init_conversion_context(&ctx);
26607     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win32_to_host(&ctx, (const VkBindImageMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
26608     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBindImageMemory2(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->bindInfoCount, pBindInfos_host);
26609     free_conversion_context(&ctx);
26610     return STATUS_SUCCESS;
26611 }
26612
26613 #ifdef _WIN64
26614 static NTSTATUS thunk64_vkBindImageMemory2KHR(void *args)
26615 {
26616     struct vkBindImageMemory2KHR_params *params = args;
26617     const VkBindImageMemoryInfo *pBindInfos_host;
26618     struct conversion_context ctx;
26619
26620     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
26621
26622     init_conversion_context(&ctx);
26623     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win64_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
26624     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
26625     free_conversion_context(&ctx);
26626     return STATUS_SUCCESS;
26627 }
26628 #endif /* _WIN64 */
26629
26630 static NTSTATUS thunk32_vkBindImageMemory2KHR(void *args)
26631 {
26632     struct
26633     {
26634         PTR32 device;
26635         uint32_t bindInfoCount;
26636         PTR32 pBindInfos;
26637         VkResult result;
26638     } *params = args;
26639     const VkBindImageMemoryInfo *pBindInfos_host;
26640     struct conversion_context ctx;
26641
26642     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
26643
26644     init_conversion_context(&ctx);
26645     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win32_to_host(&ctx, (const VkBindImageMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
26646     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBindImageMemory2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->bindInfoCount, pBindInfos_host);
26647     free_conversion_context(&ctx);
26648     return STATUS_SUCCESS;
26649 }
26650
26651 #ifdef _WIN64
26652 static NTSTATUS thunk64_vkBindOpticalFlowSessionImageNV(void *args)
26653 {
26654     struct vkBindOpticalFlowSessionImageNV_params *params = args;
26655
26656     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);
26657
26658     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);
26659     return STATUS_SUCCESS;
26660 }
26661 #endif /* _WIN64 */
26662
26663 static NTSTATUS thunk32_vkBindOpticalFlowSessionImageNV(void *args)
26664 {
26665     struct
26666     {
26667         PTR32 device;
26668         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
26669         VkOpticalFlowSessionBindingPointNV bindingPoint;
26670         VkImageView DECLSPEC_ALIGN(8) view;
26671         VkImageLayout layout;
26672         VkResult result;
26673     } *params = args;
26674
26675     TRACE("%#x, 0x%s, %#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->session), params->bindingPoint, wine_dbgstr_longlong(params->view), params->layout);
26676
26677     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBindOpticalFlowSessionImageNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->session, params->bindingPoint, params->view, params->layout);
26678     return STATUS_SUCCESS;
26679 }
26680
26681 #ifdef _WIN64
26682 static NTSTATUS thunk64_vkBuildAccelerationStructuresKHR(void *args)
26683 {
26684     struct vkBuildAccelerationStructuresKHR_params *params = args;
26685
26686     TRACE("%p, 0x%s, %u, %p, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos, params->ppBuildRangeInfos);
26687
26688     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);
26689     return STATUS_SUCCESS;
26690 }
26691 #endif /* _WIN64 */
26692
26693 static NTSTATUS thunk32_vkBuildAccelerationStructuresKHR(void *args)
26694 {
26695     struct
26696     {
26697         PTR32 device;
26698         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
26699         uint32_t infoCount;
26700         PTR32 pInfos;
26701         PTR32 ppBuildRangeInfos;
26702         VkResult result;
26703     } *params = args;
26704     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
26705     struct conversion_context ctx;
26706
26707     TRACE("%#x, 0x%s, %u, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos, params->ppBuildRangeInfos);
26708
26709     init_conversion_context(&ctx);
26710     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pInfos), params->infoCount);
26711     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBuildAccelerationStructuresKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, params->infoCount, pInfos_host, (const VkAccelerationStructureBuildRangeInfoKHR * const*)UlongToPtr(params->ppBuildRangeInfos));
26712     free_conversion_context(&ctx);
26713     return STATUS_SUCCESS;
26714 }
26715
26716 #ifdef _WIN64
26717 static NTSTATUS thunk64_vkBuildMicromapsEXT(void *args)
26718 {
26719     struct vkBuildMicromapsEXT_params *params = args;
26720
26721     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos);
26722
26723     params->result = wine_device_from_handle(params->device)->funcs.p_vkBuildMicromapsEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->infoCount, params->pInfos);
26724     return STATUS_SUCCESS;
26725 }
26726 #endif /* _WIN64 */
26727
26728 static NTSTATUS thunk32_vkBuildMicromapsEXT(void *args)
26729 {
26730     struct
26731     {
26732         PTR32 device;
26733         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
26734         uint32_t infoCount;
26735         PTR32 pInfos;
26736         VkResult result;
26737     } *params = args;
26738     const VkMicromapBuildInfoEXT *pInfos_host;
26739     struct conversion_context ctx;
26740
26741     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos);
26742
26743     init_conversion_context(&ctx);
26744     pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(&ctx, (const VkMicromapBuildInfoEXT32 *)UlongToPtr(params->pInfos), params->infoCount);
26745     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBuildMicromapsEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, params->infoCount, pInfos_host);
26746     free_conversion_context(&ctx);
26747     return STATUS_SUCCESS;
26748 }
26749
26750 #ifdef _WIN64
26751 static void thunk64_vkCmdBeginConditionalRenderingEXT(void *args)
26752 {
26753     struct vkCmdBeginConditionalRenderingEXT_params *params = args;
26754
26755     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pConditionalRenderingBegin);
26756 }
26757 #endif /* _WIN64 */
26758
26759 static void thunk32_vkCmdBeginConditionalRenderingEXT(void *args)
26760 {
26761     struct
26762     {
26763         PTR32 commandBuffer;
26764         PTR32 pConditionalRenderingBegin;
26765     } *params = args;
26766     VkConditionalRenderingBeginInfoEXT pConditionalRenderingBegin_host;
26767
26768     convert_VkConditionalRenderingBeginInfoEXT_win32_to_host((const VkConditionalRenderingBeginInfoEXT32 *)UlongToPtr(params->pConditionalRenderingBegin), &pConditionalRenderingBegin_host);
26769     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginConditionalRenderingEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pConditionalRenderingBegin_host);
26770 }
26771
26772 #ifdef _WIN64
26773 static void thunk64_vkCmdBeginDebugUtilsLabelEXT(void *args)
26774 {
26775     struct vkCmdBeginDebugUtilsLabelEXT_params *params = args;
26776
26777     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLabelInfo);
26778 }
26779 #endif /* _WIN64 */
26780
26781 static void thunk32_vkCmdBeginDebugUtilsLabelEXT(void *args)
26782 {
26783     struct
26784     {
26785         PTR32 commandBuffer;
26786         PTR32 pLabelInfo;
26787     } *params = args;
26788     VkDebugUtilsLabelEXT pLabelInfo_host;
26789
26790     convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
26791     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginDebugUtilsLabelEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pLabelInfo_host);
26792 }
26793
26794 #ifdef _WIN64
26795 static void thunk64_vkCmdBeginQuery(void *args)
26796 {
26797     struct vkCmdBeginQuery_params *params = args;
26798
26799     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);
26800 }
26801 #endif /* _WIN64 */
26802
26803 static void thunk32_vkCmdBeginQuery(void *args)
26804 {
26805     struct
26806     {
26807         PTR32 commandBuffer;
26808         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
26809         uint32_t query;
26810         VkQueryControlFlags flags;
26811     } *params = args;
26812
26813     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginQuery(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->queryPool, params->query, params->flags);
26814 }
26815
26816 #ifdef _WIN64
26817 static void thunk64_vkCmdBeginQueryIndexedEXT(void *args)
26818 {
26819     struct vkCmdBeginQueryIndexedEXT_params *params = args;
26820
26821     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);
26822 }
26823 #endif /* _WIN64 */
26824
26825 static void thunk32_vkCmdBeginQueryIndexedEXT(void *args)
26826 {
26827     struct
26828     {
26829         PTR32 commandBuffer;
26830         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
26831         uint32_t query;
26832         VkQueryControlFlags flags;
26833         uint32_t index;
26834     } *params = args;
26835
26836     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginQueryIndexedEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->queryPool, params->query, params->flags, params->index);
26837 }
26838
26839 #ifdef _WIN64
26840 static void thunk64_vkCmdBeginRenderPass(void *args)
26841 {
26842     struct vkCmdBeginRenderPass_params *params = args;
26843
26844     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->contents);
26845 }
26846 #endif /* _WIN64 */
26847
26848 static void thunk32_vkCmdBeginRenderPass(void *args)
26849 {
26850     struct
26851     {
26852         PTR32 commandBuffer;
26853         PTR32 pRenderPassBegin;
26854         VkSubpassContents contents;
26855     } *params = args;
26856     VkRenderPassBeginInfo pRenderPassBegin_host;
26857     struct conversion_context ctx;
26858
26859     init_conversion_context(&ctx);
26860     convert_VkRenderPassBeginInfo_win32_to_host(&ctx, (const VkRenderPassBeginInfo32 *)UlongToPtr(params->pRenderPassBegin), &pRenderPassBegin_host);
26861     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginRenderPass(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRenderPassBegin_host, params->contents);
26862     free_conversion_context(&ctx);
26863 }
26864
26865 #ifdef _WIN64
26866 static void thunk64_vkCmdBeginRenderPass2(void *args)
26867 {
26868     struct vkCmdBeginRenderPass2_params *params = args;
26869
26870     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
26871 }
26872 #endif /* _WIN64 */
26873
26874 static void thunk32_vkCmdBeginRenderPass2(void *args)
26875 {
26876     struct
26877     {
26878         PTR32 commandBuffer;
26879         PTR32 pRenderPassBegin;
26880         PTR32 pSubpassBeginInfo;
26881     } *params = args;
26882     VkRenderPassBeginInfo pRenderPassBegin_host;
26883     VkSubpassBeginInfo pSubpassBeginInfo_host;
26884     struct conversion_context ctx;
26885
26886     init_conversion_context(&ctx);
26887     convert_VkRenderPassBeginInfo_win32_to_host(&ctx, (const VkRenderPassBeginInfo32 *)UlongToPtr(params->pRenderPassBegin), &pRenderPassBegin_host);
26888     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
26889     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginRenderPass2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRenderPassBegin_host, &pSubpassBeginInfo_host);
26890     free_conversion_context(&ctx);
26891 }
26892
26893 #ifdef _WIN64
26894 static void thunk64_vkCmdBeginRenderPass2KHR(void *args)
26895 {
26896     struct vkCmdBeginRenderPass2KHR_params *params = args;
26897
26898     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
26899 }
26900 #endif /* _WIN64 */
26901
26902 static void thunk32_vkCmdBeginRenderPass2KHR(void *args)
26903 {
26904     struct
26905     {
26906         PTR32 commandBuffer;
26907         PTR32 pRenderPassBegin;
26908         PTR32 pSubpassBeginInfo;
26909     } *params = args;
26910     VkRenderPassBeginInfo pRenderPassBegin_host;
26911     VkSubpassBeginInfo pSubpassBeginInfo_host;
26912     struct conversion_context ctx;
26913
26914     init_conversion_context(&ctx);
26915     convert_VkRenderPassBeginInfo_win32_to_host(&ctx, (const VkRenderPassBeginInfo32 *)UlongToPtr(params->pRenderPassBegin), &pRenderPassBegin_host);
26916     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
26917     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginRenderPass2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRenderPassBegin_host, &pSubpassBeginInfo_host);
26918     free_conversion_context(&ctx);
26919 }
26920
26921 #ifdef _WIN64
26922 static void thunk64_vkCmdBeginRendering(void *args)
26923 {
26924     struct vkCmdBeginRendering_params *params = args;
26925
26926     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderingInfo);
26927 }
26928 #endif /* _WIN64 */
26929
26930 static void thunk32_vkCmdBeginRendering(void *args)
26931 {
26932     struct
26933     {
26934         PTR32 commandBuffer;
26935         PTR32 pRenderingInfo;
26936     } *params = args;
26937     VkRenderingInfo pRenderingInfo_host;
26938     struct conversion_context ctx;
26939
26940     init_conversion_context(&ctx);
26941     convert_VkRenderingInfo_win32_to_host(&ctx, (const VkRenderingInfo32 *)UlongToPtr(params->pRenderingInfo), &pRenderingInfo_host);
26942     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginRendering(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRenderingInfo_host);
26943     free_conversion_context(&ctx);
26944 }
26945
26946 #ifdef _WIN64
26947 static void thunk64_vkCmdBeginRenderingKHR(void *args)
26948 {
26949     struct vkCmdBeginRenderingKHR_params *params = args;
26950
26951     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderingInfo);
26952 }
26953 #endif /* _WIN64 */
26954
26955 static void thunk32_vkCmdBeginRenderingKHR(void *args)
26956 {
26957     struct
26958     {
26959         PTR32 commandBuffer;
26960         PTR32 pRenderingInfo;
26961     } *params = args;
26962     VkRenderingInfo pRenderingInfo_host;
26963     struct conversion_context ctx;
26964
26965     init_conversion_context(&ctx);
26966     convert_VkRenderingInfo_win32_to_host(&ctx, (const VkRenderingInfo32 *)UlongToPtr(params->pRenderingInfo), &pRenderingInfo_host);
26967     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginRenderingKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRenderingInfo_host);
26968     free_conversion_context(&ctx);
26969 }
26970
26971 #ifdef _WIN64
26972 static void thunk64_vkCmdBeginTransformFeedbackEXT(void *args)
26973 {
26974     struct vkCmdBeginTransformFeedbackEXT_params *params = args;
26975
26976     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);
26977 }
26978 #endif /* _WIN64 */
26979
26980 static void thunk32_vkCmdBeginTransformFeedbackEXT(void *args)
26981 {
26982     struct
26983     {
26984         PTR32 commandBuffer;
26985         uint32_t firstCounterBuffer;
26986         uint32_t counterBufferCount;
26987         PTR32 pCounterBuffers;
26988         PTR32 pCounterBufferOffsets;
26989     } *params = args;
26990
26991     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginTransformFeedbackEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstCounterBuffer, params->counterBufferCount, (const VkBuffer *)UlongToPtr(params->pCounterBuffers), (const VkDeviceSize *)UlongToPtr(params->pCounterBufferOffsets));
26992 }
26993
26994 #ifdef _WIN64
26995 static void thunk64_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(void *args)
26996 {
26997     struct vkCmdBindDescriptorBufferEmbeddedSamplersEXT_params *params = args;
26998
26999     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->layout, params->set);
27000 }
27001 #endif /* _WIN64 */
27002
27003 static void thunk32_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(void *args)
27004 {
27005     struct
27006     {
27007         PTR32 commandBuffer;
27008         VkPipelineBindPoint pipelineBindPoint;
27009         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
27010         uint32_t set;
27011     } *params = args;
27012
27013     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->layout, params->set);
27014 }
27015
27016 #ifdef _WIN64
27017 static void thunk64_vkCmdBindDescriptorBuffersEXT(void *args)
27018 {
27019     struct vkCmdBindDescriptorBuffersEXT_params *params = args;
27020
27021     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindDescriptorBuffersEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->bufferCount, params->pBindingInfos);
27022 }
27023 #endif /* _WIN64 */
27024
27025 static void thunk32_vkCmdBindDescriptorBuffersEXT(void *args)
27026 {
27027     struct
27028     {
27029         PTR32 commandBuffer;
27030         uint32_t bufferCount;
27031         PTR32 pBindingInfos;
27032     } *params = args;
27033     const VkDescriptorBufferBindingInfoEXT *pBindingInfos_host;
27034     struct conversion_context ctx;
27035
27036     init_conversion_context(&ctx);
27037     pBindingInfos_host = convert_VkDescriptorBufferBindingInfoEXT_array_win32_to_host(&ctx, (const VkDescriptorBufferBindingInfoEXT32 *)UlongToPtr(params->pBindingInfos), params->bufferCount);
27038     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindDescriptorBuffersEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->bufferCount, pBindingInfos_host);
27039     free_conversion_context(&ctx);
27040 }
27041
27042 #ifdef _WIN64
27043 static void thunk64_vkCmdBindDescriptorSets(void *args)
27044 {
27045     struct vkCmdBindDescriptorSets_params *params = args;
27046
27047     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);
27048 }
27049 #endif /* _WIN64 */
27050
27051 static void thunk32_vkCmdBindDescriptorSets(void *args)
27052 {
27053     struct
27054     {
27055         PTR32 commandBuffer;
27056         VkPipelineBindPoint pipelineBindPoint;
27057         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
27058         uint32_t firstSet;
27059         uint32_t descriptorSetCount;
27060         PTR32 pDescriptorSets;
27061         uint32_t dynamicOffsetCount;
27062         PTR32 pDynamicOffsets;
27063     } *params = args;
27064
27065     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindDescriptorSets(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->layout, params->firstSet, params->descriptorSetCount, (const VkDescriptorSet *)UlongToPtr(params->pDescriptorSets), params->dynamicOffsetCount, (const uint32_t *)UlongToPtr(params->pDynamicOffsets));
27066 }
27067
27068 #ifdef _WIN64
27069 static void thunk64_vkCmdBindIndexBuffer(void *args)
27070 {
27071     struct vkCmdBindIndexBuffer_params *params = args;
27072
27073     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);
27074 }
27075 #endif /* _WIN64 */
27076
27077 static void thunk32_vkCmdBindIndexBuffer(void *args)
27078 {
27079     struct
27080     {
27081         PTR32 commandBuffer;
27082         VkBuffer DECLSPEC_ALIGN(8) buffer;
27083         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27084         VkIndexType indexType;
27085     } *params = args;
27086
27087     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindIndexBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->indexType);
27088 }
27089
27090 #ifdef _WIN64
27091 static void thunk64_vkCmdBindInvocationMaskHUAWEI(void *args)
27092 {
27093     struct vkCmdBindInvocationMaskHUAWEI_params *params = args;
27094
27095     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindInvocationMaskHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
27096 }
27097 #endif /* _WIN64 */
27098
27099 static void thunk32_vkCmdBindInvocationMaskHUAWEI(void *args)
27100 {
27101     struct
27102     {
27103         PTR32 commandBuffer;
27104         VkImageView DECLSPEC_ALIGN(8) imageView;
27105         VkImageLayout imageLayout;
27106     } *params = args;
27107
27108     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindInvocationMaskHUAWEI(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->imageView, params->imageLayout);
27109 }
27110
27111 #ifdef _WIN64
27112 static void thunk64_vkCmdBindPipeline(void *args)
27113 {
27114     struct vkCmdBindPipeline_params *params = args;
27115
27116     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindPipeline(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->pipeline);
27117 }
27118 #endif /* _WIN64 */
27119
27120 static void thunk32_vkCmdBindPipeline(void *args)
27121 {
27122     struct
27123     {
27124         PTR32 commandBuffer;
27125         VkPipelineBindPoint pipelineBindPoint;
27126         VkPipeline DECLSPEC_ALIGN(8) pipeline;
27127     } *params = args;
27128
27129     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindPipeline(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->pipeline);
27130 }
27131
27132 #ifdef _WIN64
27133 static void thunk64_vkCmdBindPipelineShaderGroupNV(void *args)
27134 {
27135     struct vkCmdBindPipelineShaderGroupNV_params *params = args;
27136
27137     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);
27138 }
27139 #endif /* _WIN64 */
27140
27141 static void thunk32_vkCmdBindPipelineShaderGroupNV(void *args)
27142 {
27143     struct
27144     {
27145         PTR32 commandBuffer;
27146         VkPipelineBindPoint pipelineBindPoint;
27147         VkPipeline DECLSPEC_ALIGN(8) pipeline;
27148         uint32_t groupIndex;
27149     } *params = args;
27150
27151     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindPipelineShaderGroupNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->pipeline, params->groupIndex);
27152 }
27153
27154 #ifdef _WIN64
27155 static void thunk64_vkCmdBindShadersEXT(void *args)
27156 {
27157     struct vkCmdBindShadersEXT_params *params = args;
27158
27159     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindShadersEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stageCount, params->pStages, params->pShaders);
27160 }
27161 #endif /* _WIN64 */
27162
27163 static void thunk32_vkCmdBindShadersEXT(void *args)
27164 {
27165     struct
27166     {
27167         PTR32 commandBuffer;
27168         uint32_t stageCount;
27169         PTR32 pStages;
27170         PTR32 pShaders;
27171     } *params = args;
27172
27173     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindShadersEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stageCount, (const VkShaderStageFlagBits *)UlongToPtr(params->pStages), (const VkShaderEXT *)UlongToPtr(params->pShaders));
27174 }
27175
27176 #ifdef _WIN64
27177 static void thunk64_vkCmdBindShadingRateImageNV(void *args)
27178 {
27179     struct vkCmdBindShadingRateImageNV_params *params = args;
27180
27181     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindShadingRateImageNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
27182 }
27183 #endif /* _WIN64 */
27184
27185 static void thunk32_vkCmdBindShadingRateImageNV(void *args)
27186 {
27187     struct
27188     {
27189         PTR32 commandBuffer;
27190         VkImageView DECLSPEC_ALIGN(8) imageView;
27191         VkImageLayout imageLayout;
27192     } *params = args;
27193
27194     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindShadingRateImageNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->imageView, params->imageLayout);
27195 }
27196
27197 #ifdef _WIN64
27198 static void thunk64_vkCmdBindTransformFeedbackBuffersEXT(void *args)
27199 {
27200     struct vkCmdBindTransformFeedbackBuffersEXT_params *params = args;
27201
27202     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);
27203 }
27204 #endif /* _WIN64 */
27205
27206 static void thunk32_vkCmdBindTransformFeedbackBuffersEXT(void *args)
27207 {
27208     struct
27209     {
27210         PTR32 commandBuffer;
27211         uint32_t firstBinding;
27212         uint32_t bindingCount;
27213         PTR32 pBuffers;
27214         PTR32 pOffsets;
27215         PTR32 pSizes;
27216     } *params = args;
27217
27218     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindTransformFeedbackBuffersEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstBinding, params->bindingCount, (const VkBuffer *)UlongToPtr(params->pBuffers), (const VkDeviceSize *)UlongToPtr(params->pOffsets), (const VkDeviceSize *)UlongToPtr(params->pSizes));
27219 }
27220
27221 #ifdef _WIN64
27222 static void thunk64_vkCmdBindVertexBuffers(void *args)
27223 {
27224     struct vkCmdBindVertexBuffers_params *params = args;
27225
27226     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);
27227 }
27228 #endif /* _WIN64 */
27229
27230 static void thunk32_vkCmdBindVertexBuffers(void *args)
27231 {
27232     struct
27233     {
27234         PTR32 commandBuffer;
27235         uint32_t firstBinding;
27236         uint32_t bindingCount;
27237         PTR32 pBuffers;
27238         PTR32 pOffsets;
27239     } *params = args;
27240
27241     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindVertexBuffers(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstBinding, params->bindingCount, (const VkBuffer *)UlongToPtr(params->pBuffers), (const VkDeviceSize *)UlongToPtr(params->pOffsets));
27242 }
27243
27244 #ifdef _WIN64
27245 static void thunk64_vkCmdBindVertexBuffers2(void *args)
27246 {
27247     struct vkCmdBindVertexBuffers2_params *params = args;
27248
27249     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);
27250 }
27251 #endif /* _WIN64 */
27252
27253 static void thunk32_vkCmdBindVertexBuffers2(void *args)
27254 {
27255     struct
27256     {
27257         PTR32 commandBuffer;
27258         uint32_t firstBinding;
27259         uint32_t bindingCount;
27260         PTR32 pBuffers;
27261         PTR32 pOffsets;
27262         PTR32 pSizes;
27263         PTR32 pStrides;
27264     } *params = args;
27265
27266     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindVertexBuffers2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstBinding, params->bindingCount, (const VkBuffer *)UlongToPtr(params->pBuffers), (const VkDeviceSize *)UlongToPtr(params->pOffsets), (const VkDeviceSize *)UlongToPtr(params->pSizes), (const VkDeviceSize *)UlongToPtr(params->pStrides));
27267 }
27268
27269 #ifdef _WIN64
27270 static void thunk64_vkCmdBindVertexBuffers2EXT(void *args)
27271 {
27272     struct vkCmdBindVertexBuffers2EXT_params *params = args;
27273
27274     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);
27275 }
27276 #endif /* _WIN64 */
27277
27278 static void thunk32_vkCmdBindVertexBuffers2EXT(void *args)
27279 {
27280     struct
27281     {
27282         PTR32 commandBuffer;
27283         uint32_t firstBinding;
27284         uint32_t bindingCount;
27285         PTR32 pBuffers;
27286         PTR32 pOffsets;
27287         PTR32 pSizes;
27288         PTR32 pStrides;
27289     } *params = args;
27290
27291     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindVertexBuffers2EXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstBinding, params->bindingCount, (const VkBuffer *)UlongToPtr(params->pBuffers), (const VkDeviceSize *)UlongToPtr(params->pOffsets), (const VkDeviceSize *)UlongToPtr(params->pSizes), (const VkDeviceSize *)UlongToPtr(params->pStrides));
27292 }
27293
27294 #ifdef _WIN64
27295 static void thunk64_vkCmdBlitImage(void *args)
27296 {
27297     struct vkCmdBlitImage_params *params = args;
27298
27299     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);
27300 }
27301 #endif /* _WIN64 */
27302
27303 static void thunk32_vkCmdBlitImage(void *args)
27304 {
27305     struct
27306     {
27307         PTR32 commandBuffer;
27308         VkImage DECLSPEC_ALIGN(8) srcImage;
27309         VkImageLayout srcImageLayout;
27310         VkImage DECLSPEC_ALIGN(8) dstImage;
27311         VkImageLayout dstImageLayout;
27312         uint32_t regionCount;
27313         PTR32 pRegions;
27314         VkFilter filter;
27315     } *params = args;
27316
27317     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBlitImage(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, (const VkImageBlit *)UlongToPtr(params->pRegions), params->filter);
27318 }
27319
27320 #ifdef _WIN64
27321 static void thunk64_vkCmdBlitImage2(void *args)
27322 {
27323     struct vkCmdBlitImage2_params *params = args;
27324
27325     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBlitImageInfo);
27326 }
27327 #endif /* _WIN64 */
27328
27329 static void thunk32_vkCmdBlitImage2(void *args)
27330 {
27331     struct
27332     {
27333         PTR32 commandBuffer;
27334         PTR32 pBlitImageInfo;
27335     } *params = args;
27336     VkBlitImageInfo2 pBlitImageInfo_host;
27337     struct conversion_context ctx;
27338
27339     init_conversion_context(&ctx);
27340     convert_VkBlitImageInfo2_win32_to_host(&ctx, (const VkBlitImageInfo232 *)UlongToPtr(params->pBlitImageInfo), &pBlitImageInfo_host);
27341     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBlitImage2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pBlitImageInfo_host);
27342     free_conversion_context(&ctx);
27343 }
27344
27345 #ifdef _WIN64
27346 static void thunk64_vkCmdBlitImage2KHR(void *args)
27347 {
27348     struct vkCmdBlitImage2KHR_params *params = args;
27349
27350     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBlitImageInfo);
27351 }
27352 #endif /* _WIN64 */
27353
27354 static void thunk32_vkCmdBlitImage2KHR(void *args)
27355 {
27356     struct
27357     {
27358         PTR32 commandBuffer;
27359         PTR32 pBlitImageInfo;
27360     } *params = args;
27361     VkBlitImageInfo2 pBlitImageInfo_host;
27362     struct conversion_context ctx;
27363
27364     init_conversion_context(&ctx);
27365     convert_VkBlitImageInfo2_win32_to_host(&ctx, (const VkBlitImageInfo232 *)UlongToPtr(params->pBlitImageInfo), &pBlitImageInfo_host);
27366     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBlitImage2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pBlitImageInfo_host);
27367     free_conversion_context(&ctx);
27368 }
27369
27370 #ifdef _WIN64
27371 static void thunk64_vkCmdBuildAccelerationStructureNV(void *args)
27372 {
27373     struct vkCmdBuildAccelerationStructureNV_params *params = args;
27374
27375     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);
27376 }
27377 #endif /* _WIN64 */
27378
27379 static void thunk32_vkCmdBuildAccelerationStructureNV(void *args)
27380 {
27381     struct
27382     {
27383         PTR32 commandBuffer;
27384         PTR32 pInfo;
27385         VkBuffer DECLSPEC_ALIGN(8) instanceData;
27386         VkDeviceSize DECLSPEC_ALIGN(8) instanceOffset;
27387         VkBool32 update;
27388         VkAccelerationStructureNV DECLSPEC_ALIGN(8) dst;
27389         VkAccelerationStructureNV DECLSPEC_ALIGN(8) src;
27390         VkBuffer DECLSPEC_ALIGN(8) scratch;
27391         VkDeviceSize DECLSPEC_ALIGN(8) scratchOffset;
27392     } *params = args;
27393     VkAccelerationStructureInfoNV pInfo_host;
27394     struct conversion_context ctx;
27395
27396     init_conversion_context(&ctx);
27397     convert_VkAccelerationStructureInfoNV_win32_to_host(&ctx, (const VkAccelerationStructureInfoNV32 *)UlongToPtr(params->pInfo), &pInfo_host);
27398     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBuildAccelerationStructureNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host, params->instanceData, params->instanceOffset, params->update, params->dst, params->src, params->scratch, params->scratchOffset);
27399     free_conversion_context(&ctx);
27400 }
27401
27402 #ifdef _WIN64
27403 static void thunk64_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
27404 {
27405     struct vkCmdBuildAccelerationStructuresIndirectKHR_params *params = args;
27406
27407     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);
27408 }
27409 #endif /* _WIN64 */
27410
27411 static void thunk32_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
27412 {
27413     struct
27414     {
27415         PTR32 commandBuffer;
27416         uint32_t infoCount;
27417         PTR32 pInfos;
27418         PTR32 pIndirectDeviceAddresses;
27419         PTR32 pIndirectStrides;
27420         PTR32 ppMaxPrimitiveCounts;
27421     } *params = args;
27422     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
27423     struct conversion_context ctx;
27424
27425     init_conversion_context(&ctx);
27426     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pInfos), params->infoCount);
27427     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBuildAccelerationStructuresIndirectKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->infoCount, pInfos_host, (const VkDeviceAddress *)UlongToPtr(params->pIndirectDeviceAddresses), (const uint32_t *)UlongToPtr(params->pIndirectStrides), (const uint32_t * const*)UlongToPtr(params->ppMaxPrimitiveCounts));
27428     free_conversion_context(&ctx);
27429 }
27430
27431 #ifdef _WIN64
27432 static void thunk64_vkCmdBuildAccelerationStructuresKHR(void *args)
27433 {
27434     struct vkCmdBuildAccelerationStructuresKHR_params *params = args;
27435
27436     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);
27437 }
27438 #endif /* _WIN64 */
27439
27440 static void thunk32_vkCmdBuildAccelerationStructuresKHR(void *args)
27441 {
27442     struct
27443     {
27444         PTR32 commandBuffer;
27445         uint32_t infoCount;
27446         PTR32 pInfos;
27447         PTR32 ppBuildRangeInfos;
27448     } *params = args;
27449     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
27450     struct conversion_context ctx;
27451
27452     init_conversion_context(&ctx);
27453     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pInfos), params->infoCount);
27454     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBuildAccelerationStructuresKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->infoCount, pInfos_host, (const VkAccelerationStructureBuildRangeInfoKHR * const*)UlongToPtr(params->ppBuildRangeInfos));
27455     free_conversion_context(&ctx);
27456 }
27457
27458 #ifdef _WIN64
27459 static void thunk64_vkCmdBuildMicromapsEXT(void *args)
27460 {
27461     struct vkCmdBuildMicromapsEXT_params *params = args;
27462
27463     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildMicromapsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, params->pInfos);
27464 }
27465 #endif /* _WIN64 */
27466
27467 static void thunk32_vkCmdBuildMicromapsEXT(void *args)
27468 {
27469     struct
27470     {
27471         PTR32 commandBuffer;
27472         uint32_t infoCount;
27473         PTR32 pInfos;
27474     } *params = args;
27475     const VkMicromapBuildInfoEXT *pInfos_host;
27476     struct conversion_context ctx;
27477
27478     init_conversion_context(&ctx);
27479     pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(&ctx, (const VkMicromapBuildInfoEXT32 *)UlongToPtr(params->pInfos), params->infoCount);
27480     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBuildMicromapsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->infoCount, pInfos_host);
27481     free_conversion_context(&ctx);
27482 }
27483
27484 #ifdef _WIN64
27485 static void thunk64_vkCmdClearAttachments(void *args)
27486 {
27487     struct vkCmdClearAttachments_params *params = args;
27488
27489     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);
27490 }
27491 #endif /* _WIN64 */
27492
27493 static void thunk32_vkCmdClearAttachments(void *args)
27494 {
27495     struct
27496     {
27497         PTR32 commandBuffer;
27498         uint32_t attachmentCount;
27499         PTR32 pAttachments;
27500         uint32_t rectCount;
27501         PTR32 pRects;
27502     } *params = args;
27503
27504     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdClearAttachments(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->attachmentCount, (const VkClearAttachment *)UlongToPtr(params->pAttachments), params->rectCount, (const VkClearRect *)UlongToPtr(params->pRects));
27505 }
27506
27507 #ifdef _WIN64
27508 static void thunk64_vkCmdClearColorImage(void *args)
27509 {
27510     struct vkCmdClearColorImage_params *params = args;
27511
27512     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);
27513 }
27514 #endif /* _WIN64 */
27515
27516 static void thunk32_vkCmdClearColorImage(void *args)
27517 {
27518     struct
27519     {
27520         PTR32 commandBuffer;
27521         VkImage DECLSPEC_ALIGN(8) image;
27522         VkImageLayout imageLayout;
27523         PTR32 pColor;
27524         uint32_t rangeCount;
27525         PTR32 pRanges;
27526     } *params = args;
27527
27528     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdClearColorImage(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->image, params->imageLayout, (const VkClearColorValue *)UlongToPtr(params->pColor), params->rangeCount, (const VkImageSubresourceRange *)UlongToPtr(params->pRanges));
27529 }
27530
27531 #ifdef _WIN64
27532 static void thunk64_vkCmdClearDepthStencilImage(void *args)
27533 {
27534     struct vkCmdClearDepthStencilImage_params *params = args;
27535
27536     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);
27537 }
27538 #endif /* _WIN64 */
27539
27540 static void thunk32_vkCmdClearDepthStencilImage(void *args)
27541 {
27542     struct
27543     {
27544         PTR32 commandBuffer;
27545         VkImage DECLSPEC_ALIGN(8) image;
27546         VkImageLayout imageLayout;
27547         PTR32 pDepthStencil;
27548         uint32_t rangeCount;
27549         PTR32 pRanges;
27550     } *params = args;
27551
27552     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdClearDepthStencilImage(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->image, params->imageLayout, (const VkClearDepthStencilValue *)UlongToPtr(params->pDepthStencil), params->rangeCount, (const VkImageSubresourceRange *)UlongToPtr(params->pRanges));
27553 }
27554
27555 #ifdef _WIN64
27556 static void thunk64_vkCmdCopyAccelerationStructureKHR(void *args)
27557 {
27558     struct vkCmdCopyAccelerationStructureKHR_params *params = args;
27559
27560     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
27561 }
27562 #endif /* _WIN64 */
27563
27564 static void thunk32_vkCmdCopyAccelerationStructureKHR(void *args)
27565 {
27566     struct
27567     {
27568         PTR32 commandBuffer;
27569         PTR32 pInfo;
27570     } *params = args;
27571     VkCopyAccelerationStructureInfoKHR pInfo_host;
27572
27573     convert_VkCopyAccelerationStructureInfoKHR_win32_to_host((const VkCopyAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
27574     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyAccelerationStructureKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host);
27575 }
27576
27577 #ifdef _WIN64
27578 static void thunk64_vkCmdCopyAccelerationStructureNV(void *args)
27579 {
27580     struct vkCmdCopyAccelerationStructureNV_params *params = args;
27581
27582     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);
27583 }
27584 #endif /* _WIN64 */
27585
27586 static void thunk32_vkCmdCopyAccelerationStructureNV(void *args)
27587 {
27588     struct
27589     {
27590         PTR32 commandBuffer;
27591         VkAccelerationStructureNV DECLSPEC_ALIGN(8) dst;
27592         VkAccelerationStructureNV DECLSPEC_ALIGN(8) src;
27593         VkCopyAccelerationStructureModeKHR mode;
27594     } *params = args;
27595
27596     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyAccelerationStructureNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->dst, params->src, params->mode);
27597 }
27598
27599 #ifdef _WIN64
27600 static void thunk64_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)
27601 {
27602     struct vkCmdCopyAccelerationStructureToMemoryKHR_params *params = args;
27603
27604     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureToMemoryKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
27605 }
27606 #endif /* _WIN64 */
27607
27608 static void thunk32_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)
27609 {
27610     struct
27611     {
27612         PTR32 commandBuffer;
27613         PTR32 pInfo;
27614     } *params = args;
27615     VkCopyAccelerationStructureToMemoryInfoKHR pInfo_host;
27616
27617     convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host((const VkCopyAccelerationStructureToMemoryInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
27618     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyAccelerationStructureToMemoryKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host);
27619 }
27620
27621 #ifdef _WIN64
27622 static void thunk64_vkCmdCopyBuffer(void *args)
27623 {
27624     struct vkCmdCopyBuffer_params *params = args;
27625
27626     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);
27627 }
27628 #endif /* _WIN64 */
27629
27630 static void thunk32_vkCmdCopyBuffer(void *args)
27631 {
27632     struct
27633     {
27634         PTR32 commandBuffer;
27635         VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
27636         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
27637         uint32_t regionCount;
27638         PTR32 pRegions;
27639     } *params = args;
27640     const VkBufferCopy *pRegions_host;
27641     struct conversion_context ctx;
27642
27643     init_conversion_context(&ctx);
27644     pRegions_host = convert_VkBufferCopy_array_win32_to_host(&ctx, (const VkBufferCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
27645     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcBuffer, params->dstBuffer, params->regionCount, pRegions_host);
27646     free_conversion_context(&ctx);
27647 }
27648
27649 #ifdef _WIN64
27650 static void thunk64_vkCmdCopyBuffer2(void *args)
27651 {
27652     struct vkCmdCopyBuffer2_params *params = args;
27653
27654     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferInfo);
27655 }
27656 #endif /* _WIN64 */
27657
27658 static void thunk32_vkCmdCopyBuffer2(void *args)
27659 {
27660     struct
27661     {
27662         PTR32 commandBuffer;
27663         PTR32 pCopyBufferInfo;
27664     } *params = args;
27665     VkCopyBufferInfo2 pCopyBufferInfo_host;
27666     struct conversion_context ctx;
27667
27668     init_conversion_context(&ctx);
27669     convert_VkCopyBufferInfo2_win32_to_host(&ctx, (const VkCopyBufferInfo232 *)UlongToPtr(params->pCopyBufferInfo), &pCopyBufferInfo_host);
27670     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBuffer2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyBufferInfo_host);
27671     free_conversion_context(&ctx);
27672 }
27673
27674 #ifdef _WIN64
27675 static void thunk64_vkCmdCopyBuffer2KHR(void *args)
27676 {
27677     struct vkCmdCopyBuffer2KHR_params *params = args;
27678
27679     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferInfo);
27680 }
27681 #endif /* _WIN64 */
27682
27683 static void thunk32_vkCmdCopyBuffer2KHR(void *args)
27684 {
27685     struct
27686     {
27687         PTR32 commandBuffer;
27688         PTR32 pCopyBufferInfo;
27689     } *params = args;
27690     VkCopyBufferInfo2 pCopyBufferInfo_host;
27691     struct conversion_context ctx;
27692
27693     init_conversion_context(&ctx);
27694     convert_VkCopyBufferInfo2_win32_to_host(&ctx, (const VkCopyBufferInfo232 *)UlongToPtr(params->pCopyBufferInfo), &pCopyBufferInfo_host);
27695     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBuffer2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyBufferInfo_host);
27696     free_conversion_context(&ctx);
27697 }
27698
27699 #ifdef _WIN64
27700 static void thunk64_vkCmdCopyBufferToImage(void *args)
27701 {
27702     struct vkCmdCopyBufferToImage_params *params = args;
27703
27704     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);
27705 }
27706 #endif /* _WIN64 */
27707
27708 static void thunk32_vkCmdCopyBufferToImage(void *args)
27709 {
27710     struct
27711     {
27712         PTR32 commandBuffer;
27713         VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
27714         VkImage DECLSPEC_ALIGN(8) dstImage;
27715         VkImageLayout dstImageLayout;
27716         uint32_t regionCount;
27717         PTR32 pRegions;
27718     } *params = args;
27719     const VkBufferImageCopy *pRegions_host;
27720     struct conversion_context ctx;
27721
27722     init_conversion_context(&ctx);
27723     pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(&ctx, (const VkBufferImageCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
27724     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBufferToImage(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcBuffer, params->dstImage, params->dstImageLayout, params->regionCount, pRegions_host);
27725     free_conversion_context(&ctx);
27726 }
27727
27728 #ifdef _WIN64
27729 static void thunk64_vkCmdCopyBufferToImage2(void *args)
27730 {
27731     struct vkCmdCopyBufferToImage2_params *params = args;
27732
27733     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferToImageInfo);
27734 }
27735 #endif /* _WIN64 */
27736
27737 static void thunk32_vkCmdCopyBufferToImage2(void *args)
27738 {
27739     struct
27740     {
27741         PTR32 commandBuffer;
27742         PTR32 pCopyBufferToImageInfo;
27743     } *params = args;
27744     VkCopyBufferToImageInfo2 pCopyBufferToImageInfo_host;
27745     struct conversion_context ctx;
27746
27747     init_conversion_context(&ctx);
27748     convert_VkCopyBufferToImageInfo2_win32_to_host(&ctx, (const VkCopyBufferToImageInfo232 *)UlongToPtr(params->pCopyBufferToImageInfo), &pCopyBufferToImageInfo_host);
27749     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBufferToImage2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyBufferToImageInfo_host);
27750     free_conversion_context(&ctx);
27751 }
27752
27753 #ifdef _WIN64
27754 static void thunk64_vkCmdCopyBufferToImage2KHR(void *args)
27755 {
27756     struct vkCmdCopyBufferToImage2KHR_params *params = args;
27757
27758     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferToImageInfo);
27759 }
27760 #endif /* _WIN64 */
27761
27762 static void thunk32_vkCmdCopyBufferToImage2KHR(void *args)
27763 {
27764     struct
27765     {
27766         PTR32 commandBuffer;
27767         PTR32 pCopyBufferToImageInfo;
27768     } *params = args;
27769     VkCopyBufferToImageInfo2 pCopyBufferToImageInfo_host;
27770     struct conversion_context ctx;
27771
27772     init_conversion_context(&ctx);
27773     convert_VkCopyBufferToImageInfo2_win32_to_host(&ctx, (const VkCopyBufferToImageInfo232 *)UlongToPtr(params->pCopyBufferToImageInfo), &pCopyBufferToImageInfo_host);
27774     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBufferToImage2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyBufferToImageInfo_host);
27775     free_conversion_context(&ctx);
27776 }
27777
27778 #ifdef _WIN64
27779 static void thunk64_vkCmdCopyImage(void *args)
27780 {
27781     struct vkCmdCopyImage_params *params = args;
27782
27783     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);
27784 }
27785 #endif /* _WIN64 */
27786
27787 static void thunk32_vkCmdCopyImage(void *args)
27788 {
27789     struct
27790     {
27791         PTR32 commandBuffer;
27792         VkImage DECLSPEC_ALIGN(8) srcImage;
27793         VkImageLayout srcImageLayout;
27794         VkImage DECLSPEC_ALIGN(8) dstImage;
27795         VkImageLayout dstImageLayout;
27796         uint32_t regionCount;
27797         PTR32 pRegions;
27798     } *params = args;
27799
27800     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImage(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, (const VkImageCopy *)UlongToPtr(params->pRegions));
27801 }
27802
27803 #ifdef _WIN64
27804 static void thunk64_vkCmdCopyImage2(void *args)
27805 {
27806     struct vkCmdCopyImage2_params *params = args;
27807
27808     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageInfo);
27809 }
27810 #endif /* _WIN64 */
27811
27812 static void thunk32_vkCmdCopyImage2(void *args)
27813 {
27814     struct
27815     {
27816         PTR32 commandBuffer;
27817         PTR32 pCopyImageInfo;
27818     } *params = args;
27819     VkCopyImageInfo2 pCopyImageInfo_host;
27820     struct conversion_context ctx;
27821
27822     init_conversion_context(&ctx);
27823     convert_VkCopyImageInfo2_win32_to_host(&ctx, (const VkCopyImageInfo232 *)UlongToPtr(params->pCopyImageInfo), &pCopyImageInfo_host);
27824     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImage2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyImageInfo_host);
27825     free_conversion_context(&ctx);
27826 }
27827
27828 #ifdef _WIN64
27829 static void thunk64_vkCmdCopyImage2KHR(void *args)
27830 {
27831     struct vkCmdCopyImage2KHR_params *params = args;
27832
27833     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageInfo);
27834 }
27835 #endif /* _WIN64 */
27836
27837 static void thunk32_vkCmdCopyImage2KHR(void *args)
27838 {
27839     struct
27840     {
27841         PTR32 commandBuffer;
27842         PTR32 pCopyImageInfo;
27843     } *params = args;
27844     VkCopyImageInfo2 pCopyImageInfo_host;
27845     struct conversion_context ctx;
27846
27847     init_conversion_context(&ctx);
27848     convert_VkCopyImageInfo2_win32_to_host(&ctx, (const VkCopyImageInfo232 *)UlongToPtr(params->pCopyImageInfo), &pCopyImageInfo_host);
27849     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImage2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyImageInfo_host);
27850     free_conversion_context(&ctx);
27851 }
27852
27853 #ifdef _WIN64
27854 static void thunk64_vkCmdCopyImageToBuffer(void *args)
27855 {
27856     struct vkCmdCopyImageToBuffer_params *params = args;
27857
27858     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);
27859 }
27860 #endif /* _WIN64 */
27861
27862 static void thunk32_vkCmdCopyImageToBuffer(void *args)
27863 {
27864     struct
27865     {
27866         PTR32 commandBuffer;
27867         VkImage DECLSPEC_ALIGN(8) srcImage;
27868         VkImageLayout srcImageLayout;
27869         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
27870         uint32_t regionCount;
27871         PTR32 pRegions;
27872     } *params = args;
27873     const VkBufferImageCopy *pRegions_host;
27874     struct conversion_context ctx;
27875
27876     init_conversion_context(&ctx);
27877     pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(&ctx, (const VkBufferImageCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
27878     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImageToBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcImage, params->srcImageLayout, params->dstBuffer, params->regionCount, pRegions_host);
27879     free_conversion_context(&ctx);
27880 }
27881
27882 #ifdef _WIN64
27883 static void thunk64_vkCmdCopyImageToBuffer2(void *args)
27884 {
27885     struct vkCmdCopyImageToBuffer2_params *params = args;
27886
27887     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageToBufferInfo);
27888 }
27889 #endif /* _WIN64 */
27890
27891 static void thunk32_vkCmdCopyImageToBuffer2(void *args)
27892 {
27893     struct
27894     {
27895         PTR32 commandBuffer;
27896         PTR32 pCopyImageToBufferInfo;
27897     } *params = args;
27898     VkCopyImageToBufferInfo2 pCopyImageToBufferInfo_host;
27899     struct conversion_context ctx;
27900
27901     init_conversion_context(&ctx);
27902     convert_VkCopyImageToBufferInfo2_win32_to_host(&ctx, (const VkCopyImageToBufferInfo232 *)UlongToPtr(params->pCopyImageToBufferInfo), &pCopyImageToBufferInfo_host);
27903     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImageToBuffer2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyImageToBufferInfo_host);
27904     free_conversion_context(&ctx);
27905 }
27906
27907 #ifdef _WIN64
27908 static void thunk64_vkCmdCopyImageToBuffer2KHR(void *args)
27909 {
27910     struct vkCmdCopyImageToBuffer2KHR_params *params = args;
27911
27912     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageToBufferInfo);
27913 }
27914 #endif /* _WIN64 */
27915
27916 static void thunk32_vkCmdCopyImageToBuffer2KHR(void *args)
27917 {
27918     struct
27919     {
27920         PTR32 commandBuffer;
27921         PTR32 pCopyImageToBufferInfo;
27922     } *params = args;
27923     VkCopyImageToBufferInfo2 pCopyImageToBufferInfo_host;
27924     struct conversion_context ctx;
27925
27926     init_conversion_context(&ctx);
27927     convert_VkCopyImageToBufferInfo2_win32_to_host(&ctx, (const VkCopyImageToBufferInfo232 *)UlongToPtr(params->pCopyImageToBufferInfo), &pCopyImageToBufferInfo_host);
27928     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImageToBuffer2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyImageToBufferInfo_host);
27929     free_conversion_context(&ctx);
27930 }
27931
27932 #ifdef _WIN64
27933 static void thunk64_vkCmdCopyMemoryIndirectNV(void *args)
27934 {
27935     struct vkCmdCopyMemoryIndirectNV_params *params = args;
27936
27937     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);
27938 }
27939 #endif /* _WIN64 */
27940
27941 static void thunk32_vkCmdCopyMemoryIndirectNV(void *args)
27942 {
27943     struct
27944     {
27945         PTR32 commandBuffer;
27946         VkDeviceAddress DECLSPEC_ALIGN(8) copyBufferAddress;
27947         uint32_t copyCount;
27948         uint32_t stride;
27949     } *params = args;
27950
27951     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyMemoryIndirectNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->copyBufferAddress, params->copyCount, params->stride);
27952 }
27953
27954 #ifdef _WIN64
27955 static void thunk64_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
27956 {
27957     struct vkCmdCopyMemoryToAccelerationStructureKHR_params *params = args;
27958
27959     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
27960 }
27961 #endif /* _WIN64 */
27962
27963 static void thunk32_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
27964 {
27965     struct
27966     {
27967         PTR32 commandBuffer;
27968         PTR32 pInfo;
27969     } *params = args;
27970     VkCopyMemoryToAccelerationStructureInfoKHR pInfo_host;
27971
27972     convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host((const VkCopyMemoryToAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
27973     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyMemoryToAccelerationStructureKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host);
27974 }
27975
27976 #ifdef _WIN64
27977 static void thunk64_vkCmdCopyMemoryToImageIndirectNV(void *args)
27978 {
27979     struct vkCmdCopyMemoryToImageIndirectNV_params *params = args;
27980
27981     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);
27982 }
27983 #endif /* _WIN64 */
27984
27985 static void thunk32_vkCmdCopyMemoryToImageIndirectNV(void *args)
27986 {
27987     struct
27988     {
27989         PTR32 commandBuffer;
27990         VkDeviceAddress DECLSPEC_ALIGN(8) copyBufferAddress;
27991         uint32_t copyCount;
27992         uint32_t stride;
27993         VkImage DECLSPEC_ALIGN(8) dstImage;
27994         VkImageLayout dstImageLayout;
27995         PTR32 pImageSubresources;
27996     } *params = args;
27997
27998     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyMemoryToImageIndirectNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->copyBufferAddress, params->copyCount, params->stride, params->dstImage, params->dstImageLayout, (const VkImageSubresourceLayers *)UlongToPtr(params->pImageSubresources));
27999 }
28000
28001 #ifdef _WIN64
28002 static void thunk64_vkCmdCopyMemoryToMicromapEXT(void *args)
28003 {
28004     struct vkCmdCopyMemoryToMicromapEXT_params *params = args;
28005
28006     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
28007 }
28008 #endif /* _WIN64 */
28009
28010 static void thunk32_vkCmdCopyMemoryToMicromapEXT(void *args)
28011 {
28012     struct
28013     {
28014         PTR32 commandBuffer;
28015         PTR32 pInfo;
28016     } *params = args;
28017     VkCopyMemoryToMicromapInfoEXT pInfo_host;
28018
28019     convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host((const VkCopyMemoryToMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
28020     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyMemoryToMicromapEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host);
28021 }
28022
28023 #ifdef _WIN64
28024 static void thunk64_vkCmdCopyMicromapEXT(void *args)
28025 {
28026     struct vkCmdCopyMicromapEXT_params *params = args;
28027
28028     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
28029 }
28030 #endif /* _WIN64 */
28031
28032 static void thunk32_vkCmdCopyMicromapEXT(void *args)
28033 {
28034     struct
28035     {
28036         PTR32 commandBuffer;
28037         PTR32 pInfo;
28038     } *params = args;
28039     VkCopyMicromapInfoEXT pInfo_host;
28040
28041     convert_VkCopyMicromapInfoEXT_win32_to_host((const VkCopyMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
28042     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyMicromapEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host);
28043 }
28044
28045 #ifdef _WIN64
28046 static void thunk64_vkCmdCopyMicromapToMemoryEXT(void *args)
28047 {
28048     struct vkCmdCopyMicromapToMemoryEXT_params *params = args;
28049
28050     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapToMemoryEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
28051 }
28052 #endif /* _WIN64 */
28053
28054 static void thunk32_vkCmdCopyMicromapToMemoryEXT(void *args)
28055 {
28056     struct
28057     {
28058         PTR32 commandBuffer;
28059         PTR32 pInfo;
28060     } *params = args;
28061     VkCopyMicromapToMemoryInfoEXT pInfo_host;
28062
28063     convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host((const VkCopyMicromapToMemoryInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
28064     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyMicromapToMemoryEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host);
28065 }
28066
28067 #ifdef _WIN64
28068 static void thunk64_vkCmdCopyQueryPoolResults(void *args)
28069 {
28070     struct vkCmdCopyQueryPoolResults_params *params = args;
28071
28072     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);
28073 }
28074 #endif /* _WIN64 */
28075
28076 static void thunk32_vkCmdCopyQueryPoolResults(void *args)
28077 {
28078     struct
28079     {
28080         PTR32 commandBuffer;
28081         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
28082         uint32_t firstQuery;
28083         uint32_t queryCount;
28084         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
28085         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
28086         VkDeviceSize DECLSPEC_ALIGN(8) stride;
28087         VkQueryResultFlags flags;
28088     } *params = args;
28089
28090     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyQueryPoolResults(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->queryPool, params->firstQuery, params->queryCount, params->dstBuffer, params->dstOffset, params->stride, params->flags);
28091 }
28092
28093 #ifdef _WIN64
28094 static void thunk64_vkCmdCuLaunchKernelNVX(void *args)
28095 {
28096     struct vkCmdCuLaunchKernelNVX_params *params = args;
28097
28098     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCuLaunchKernelNVX(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLaunchInfo);
28099 }
28100 #endif /* _WIN64 */
28101
28102 static void thunk32_vkCmdCuLaunchKernelNVX(void *args)
28103 {
28104     struct
28105     {
28106         PTR32 commandBuffer;
28107         PTR32 pLaunchInfo;
28108     } *params = args;
28109     VkCuLaunchInfoNVX pLaunchInfo_host;
28110
28111     convert_VkCuLaunchInfoNVX_win32_to_host((const VkCuLaunchInfoNVX32 *)UlongToPtr(params->pLaunchInfo), &pLaunchInfo_host);
28112     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCuLaunchKernelNVX(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pLaunchInfo_host);
28113 }
28114
28115 #ifdef _WIN64
28116 static void thunk64_vkCmdDebugMarkerBeginEXT(void *args)
28117 {
28118     struct vkCmdDebugMarkerBeginEXT_params *params = args;
28119
28120     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerBeginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
28121 }
28122 #endif /* _WIN64 */
28123
28124 static void thunk32_vkCmdDebugMarkerBeginEXT(void *args)
28125 {
28126     struct
28127     {
28128         PTR32 commandBuffer;
28129         PTR32 pMarkerInfo;
28130     } *params = args;
28131     VkDebugMarkerMarkerInfoEXT pMarkerInfo_host;
28132
28133     convert_VkDebugMarkerMarkerInfoEXT_win32_to_host((const VkDebugMarkerMarkerInfoEXT32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
28134     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDebugMarkerBeginEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pMarkerInfo_host);
28135 }
28136
28137 #ifdef _WIN64
28138 static void thunk64_vkCmdDebugMarkerEndEXT(void *args)
28139 {
28140     struct vkCmdDebugMarkerEndEXT_params *params = args;
28141
28142     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerEndEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
28143 }
28144 #endif /* _WIN64 */
28145
28146 static void thunk32_vkCmdDebugMarkerEndEXT(void *args)
28147 {
28148     struct
28149     {
28150         PTR32 commandBuffer;
28151     } *params = args;
28152
28153     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDebugMarkerEndEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
28154 }
28155
28156 #ifdef _WIN64
28157 static void thunk64_vkCmdDebugMarkerInsertEXT(void *args)
28158 {
28159     struct vkCmdDebugMarkerInsertEXT_params *params = args;
28160
28161     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerInsertEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
28162 }
28163 #endif /* _WIN64 */
28164
28165 static void thunk32_vkCmdDebugMarkerInsertEXT(void *args)
28166 {
28167     struct
28168     {
28169         PTR32 commandBuffer;
28170         PTR32 pMarkerInfo;
28171     } *params = args;
28172     VkDebugMarkerMarkerInfoEXT pMarkerInfo_host;
28173
28174     convert_VkDebugMarkerMarkerInfoEXT_win32_to_host((const VkDebugMarkerMarkerInfoEXT32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
28175     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDebugMarkerInsertEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pMarkerInfo_host);
28176 }
28177
28178 #ifdef _WIN64
28179 static void thunk64_vkCmdDecompressMemoryIndirectCountNV(void *args)
28180 {
28181     struct vkCmdDecompressMemoryIndirectCountNV_params *params = args;
28182
28183     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);
28184 }
28185 #endif /* _WIN64 */
28186
28187 static void thunk32_vkCmdDecompressMemoryIndirectCountNV(void *args)
28188 {
28189     struct
28190     {
28191         PTR32 commandBuffer;
28192         VkDeviceAddress DECLSPEC_ALIGN(8) indirectCommandsAddress;
28193         VkDeviceAddress DECLSPEC_ALIGN(8) indirectCommandsCountAddress;
28194         uint32_t stride;
28195     } *params = args;
28196
28197     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDecompressMemoryIndirectCountNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->indirectCommandsAddress, params->indirectCommandsCountAddress, params->stride);
28198 }
28199
28200 #ifdef _WIN64
28201 static void thunk64_vkCmdDecompressMemoryNV(void *args)
28202 {
28203     struct vkCmdDecompressMemoryNV_params *params = args;
28204
28205     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDecompressMemoryNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->decompressRegionCount, params->pDecompressMemoryRegions);
28206 }
28207 #endif /* _WIN64 */
28208
28209 static void thunk32_vkCmdDecompressMemoryNV(void *args)
28210 {
28211     struct
28212     {
28213         PTR32 commandBuffer;
28214         uint32_t decompressRegionCount;
28215         PTR32 pDecompressMemoryRegions;
28216     } *params = args;
28217     const VkDecompressMemoryRegionNV *pDecompressMemoryRegions_host;
28218     struct conversion_context ctx;
28219
28220     init_conversion_context(&ctx);
28221     pDecompressMemoryRegions_host = convert_VkDecompressMemoryRegionNV_array_win32_to_host(&ctx, (const VkDecompressMemoryRegionNV32 *)UlongToPtr(params->pDecompressMemoryRegions), params->decompressRegionCount);
28222     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDecompressMemoryNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->decompressRegionCount, pDecompressMemoryRegions_host);
28223     free_conversion_context(&ctx);
28224 }
28225
28226 #ifdef _WIN64
28227 static void thunk64_vkCmdDispatch(void *args)
28228 {
28229     struct vkCmdDispatch_params *params = args;
28230
28231     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);
28232 }
28233 #endif /* _WIN64 */
28234
28235 static void thunk32_vkCmdDispatch(void *args)
28236 {
28237     struct
28238     {
28239         PTR32 commandBuffer;
28240         uint32_t groupCountX;
28241         uint32_t groupCountY;
28242         uint32_t groupCountZ;
28243     } *params = args;
28244
28245     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDispatch(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->groupCountX, params->groupCountY, params->groupCountZ);
28246 }
28247
28248 #ifdef _WIN64
28249 static void thunk64_vkCmdDispatchBase(void *args)
28250 {
28251     struct vkCmdDispatchBase_params *params = args;
28252
28253     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);
28254 }
28255 #endif /* _WIN64 */
28256
28257 static void thunk32_vkCmdDispatchBase(void *args)
28258 {
28259     struct
28260     {
28261         PTR32 commandBuffer;
28262         uint32_t baseGroupX;
28263         uint32_t baseGroupY;
28264         uint32_t baseGroupZ;
28265         uint32_t groupCountX;
28266         uint32_t groupCountY;
28267         uint32_t groupCountZ;
28268     } *params = args;
28269
28270     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDispatchBase(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
28271 }
28272
28273 #ifdef _WIN64
28274 static void thunk64_vkCmdDispatchBaseKHR(void *args)
28275 {
28276     struct vkCmdDispatchBaseKHR_params *params = args;
28277
28278     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);
28279 }
28280 #endif /* _WIN64 */
28281
28282 static void thunk32_vkCmdDispatchBaseKHR(void *args)
28283 {
28284     struct
28285     {
28286         PTR32 commandBuffer;
28287         uint32_t baseGroupX;
28288         uint32_t baseGroupY;
28289         uint32_t baseGroupZ;
28290         uint32_t groupCountX;
28291         uint32_t groupCountY;
28292         uint32_t groupCountZ;
28293     } *params = args;
28294
28295     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDispatchBaseKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
28296 }
28297
28298 #ifdef _WIN64
28299 static void thunk64_vkCmdDispatchIndirect(void *args)
28300 {
28301     struct vkCmdDispatchIndirect_params *params = args;
28302
28303     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset);
28304 }
28305 #endif /* _WIN64 */
28306
28307 static void thunk32_vkCmdDispatchIndirect(void *args)
28308 {
28309     struct
28310     {
28311         PTR32 commandBuffer;
28312         VkBuffer DECLSPEC_ALIGN(8) buffer;
28313         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28314     } *params = args;
28315
28316     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDispatchIndirect(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset);
28317 }
28318
28319 #ifdef _WIN64
28320 static void thunk64_vkCmdDraw(void *args)
28321 {
28322     struct vkCmdDraw_params *params = args;
28323
28324     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);
28325 }
28326 #endif /* _WIN64 */
28327
28328 static void thunk32_vkCmdDraw(void *args)
28329 {
28330     struct
28331     {
28332         PTR32 commandBuffer;
28333         uint32_t vertexCount;
28334         uint32_t instanceCount;
28335         uint32_t firstVertex;
28336         uint32_t firstInstance;
28337     } *params = args;
28338
28339     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDraw(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->vertexCount, params->instanceCount, params->firstVertex, params->firstInstance);
28340 }
28341
28342 #ifdef _WIN64
28343 static void thunk64_vkCmdDrawClusterHUAWEI(void *args)
28344 {
28345     struct vkCmdDrawClusterHUAWEI_params *params = args;
28346
28347     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawClusterHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->groupCountX, params->groupCountY, params->groupCountZ);
28348 }
28349 #endif /* _WIN64 */
28350
28351 static void thunk32_vkCmdDrawClusterHUAWEI(void *args)
28352 {
28353     struct
28354     {
28355         PTR32 commandBuffer;
28356         uint32_t groupCountX;
28357         uint32_t groupCountY;
28358         uint32_t groupCountZ;
28359     } *params = args;
28360
28361     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawClusterHUAWEI(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->groupCountX, params->groupCountY, params->groupCountZ);
28362 }
28363
28364 #ifdef _WIN64
28365 static void thunk64_vkCmdDrawClusterIndirectHUAWEI(void *args)
28366 {
28367     struct vkCmdDrawClusterIndirectHUAWEI_params *params = args;
28368
28369     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawClusterIndirectHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset);
28370 }
28371 #endif /* _WIN64 */
28372
28373 static void thunk32_vkCmdDrawClusterIndirectHUAWEI(void *args)
28374 {
28375     struct
28376     {
28377         PTR32 commandBuffer;
28378         VkBuffer DECLSPEC_ALIGN(8) buffer;
28379         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28380     } *params = args;
28381
28382     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawClusterIndirectHUAWEI(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset);
28383 }
28384
28385 #ifdef _WIN64
28386 static void thunk64_vkCmdDrawIndexed(void *args)
28387 {
28388     struct vkCmdDrawIndexed_params *params = args;
28389
28390     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);
28391 }
28392 #endif /* _WIN64 */
28393
28394 static void thunk32_vkCmdDrawIndexed(void *args)
28395 {
28396     struct
28397     {
28398         PTR32 commandBuffer;
28399         uint32_t indexCount;
28400         uint32_t instanceCount;
28401         uint32_t firstIndex;
28402         int32_t vertexOffset;
28403         uint32_t firstInstance;
28404     } *params = args;
28405
28406     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndexed(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->indexCount, params->instanceCount, params->firstIndex, params->vertexOffset, params->firstInstance);
28407 }
28408
28409 #ifdef _WIN64
28410 static void thunk64_vkCmdDrawIndexedIndirect(void *args)
28411 {
28412     struct vkCmdDrawIndexedIndirect_params *params = args;
28413
28414     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);
28415 }
28416 #endif /* _WIN64 */
28417
28418 static void thunk32_vkCmdDrawIndexedIndirect(void *args)
28419 {
28420     struct
28421     {
28422         PTR32 commandBuffer;
28423         VkBuffer DECLSPEC_ALIGN(8) buffer;
28424         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28425         uint32_t drawCount;
28426         uint32_t stride;
28427     } *params = args;
28428
28429     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndexedIndirect(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
28430 }
28431
28432 #ifdef _WIN64
28433 static void thunk64_vkCmdDrawIndexedIndirectCount(void *args)
28434 {
28435     struct vkCmdDrawIndexedIndirectCount_params *params = args;
28436
28437     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);
28438 }
28439 #endif /* _WIN64 */
28440
28441 static void thunk32_vkCmdDrawIndexedIndirectCount(void *args)
28442 {
28443     struct
28444     {
28445         PTR32 commandBuffer;
28446         VkBuffer DECLSPEC_ALIGN(8) buffer;
28447         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28448         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
28449         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
28450         uint32_t maxDrawCount;
28451         uint32_t stride;
28452     } *params = args;
28453
28454     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndexedIndirectCount(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
28455 }
28456
28457 #ifdef _WIN64
28458 static void thunk64_vkCmdDrawIndexedIndirectCountAMD(void *args)
28459 {
28460     struct vkCmdDrawIndexedIndirectCountAMD_params *params = args;
28461
28462     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);
28463 }
28464 #endif /* _WIN64 */
28465
28466 static void thunk32_vkCmdDrawIndexedIndirectCountAMD(void *args)
28467 {
28468     struct
28469     {
28470         PTR32 commandBuffer;
28471         VkBuffer DECLSPEC_ALIGN(8) buffer;
28472         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28473         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
28474         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
28475         uint32_t maxDrawCount;
28476         uint32_t stride;
28477     } *params = args;
28478
28479     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndexedIndirectCountAMD(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
28480 }
28481
28482 #ifdef _WIN64
28483 static void thunk64_vkCmdDrawIndexedIndirectCountKHR(void *args)
28484 {
28485     struct vkCmdDrawIndexedIndirectCountKHR_params *params = args;
28486
28487     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);
28488 }
28489 #endif /* _WIN64 */
28490
28491 static void thunk32_vkCmdDrawIndexedIndirectCountKHR(void *args)
28492 {
28493     struct
28494     {
28495         PTR32 commandBuffer;
28496         VkBuffer DECLSPEC_ALIGN(8) buffer;
28497         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28498         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
28499         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
28500         uint32_t maxDrawCount;
28501         uint32_t stride;
28502     } *params = args;
28503
28504     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndexedIndirectCountKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
28505 }
28506
28507 #ifdef _WIN64
28508 static void thunk64_vkCmdDrawIndirect(void *args)
28509 {
28510     struct vkCmdDrawIndirect_params *params = args;
28511
28512     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);
28513 }
28514 #endif /* _WIN64 */
28515
28516 static void thunk32_vkCmdDrawIndirect(void *args)
28517 {
28518     struct
28519     {
28520         PTR32 commandBuffer;
28521         VkBuffer DECLSPEC_ALIGN(8) buffer;
28522         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28523         uint32_t drawCount;
28524         uint32_t stride;
28525     } *params = args;
28526
28527     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndirect(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
28528 }
28529
28530 #ifdef _WIN64
28531 static void thunk64_vkCmdDrawIndirectByteCountEXT(void *args)
28532 {
28533     struct vkCmdDrawIndirectByteCountEXT_params *params = args;
28534
28535     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);
28536 }
28537 #endif /* _WIN64 */
28538
28539 static void thunk32_vkCmdDrawIndirectByteCountEXT(void *args)
28540 {
28541     struct
28542     {
28543         PTR32 commandBuffer;
28544         uint32_t instanceCount;
28545         uint32_t firstInstance;
28546         VkBuffer DECLSPEC_ALIGN(8) counterBuffer;
28547         VkDeviceSize DECLSPEC_ALIGN(8) counterBufferOffset;
28548         uint32_t counterOffset;
28549         uint32_t vertexStride;
28550     } *params = args;
28551
28552     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndirectByteCountEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->instanceCount, params->firstInstance, params->counterBuffer, params->counterBufferOffset, params->counterOffset, params->vertexStride);
28553 }
28554
28555 #ifdef _WIN64
28556 static void thunk64_vkCmdDrawIndirectCount(void *args)
28557 {
28558     struct vkCmdDrawIndirectCount_params *params = args;
28559
28560     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);
28561 }
28562 #endif /* _WIN64 */
28563
28564 static void thunk32_vkCmdDrawIndirectCount(void *args)
28565 {
28566     struct
28567     {
28568         PTR32 commandBuffer;
28569         VkBuffer DECLSPEC_ALIGN(8) buffer;
28570         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28571         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
28572         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
28573         uint32_t maxDrawCount;
28574         uint32_t stride;
28575     } *params = args;
28576
28577     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndirectCount(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
28578 }
28579
28580 #ifdef _WIN64
28581 static void thunk64_vkCmdDrawIndirectCountAMD(void *args)
28582 {
28583     struct vkCmdDrawIndirectCountAMD_params *params = args;
28584
28585     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);
28586 }
28587 #endif /* _WIN64 */
28588
28589 static void thunk32_vkCmdDrawIndirectCountAMD(void *args)
28590 {
28591     struct
28592     {
28593         PTR32 commandBuffer;
28594         VkBuffer DECLSPEC_ALIGN(8) buffer;
28595         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28596         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
28597         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
28598         uint32_t maxDrawCount;
28599         uint32_t stride;
28600     } *params = args;
28601
28602     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndirectCountAMD(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
28603 }
28604
28605 #ifdef _WIN64
28606 static void thunk64_vkCmdDrawIndirectCountKHR(void *args)
28607 {
28608     struct vkCmdDrawIndirectCountKHR_params *params = args;
28609
28610     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);
28611 }
28612 #endif /* _WIN64 */
28613
28614 static void thunk32_vkCmdDrawIndirectCountKHR(void *args)
28615 {
28616     struct
28617     {
28618         PTR32 commandBuffer;
28619         VkBuffer DECLSPEC_ALIGN(8) buffer;
28620         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28621         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
28622         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
28623         uint32_t maxDrawCount;
28624         uint32_t stride;
28625     } *params = args;
28626
28627     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndirectCountKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
28628 }
28629
28630 #ifdef _WIN64
28631 static void thunk64_vkCmdDrawMeshTasksEXT(void *args)
28632 {
28633     struct vkCmdDrawMeshTasksEXT_params *params = args;
28634
28635     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);
28636 }
28637 #endif /* _WIN64 */
28638
28639 static void thunk32_vkCmdDrawMeshTasksEXT(void *args)
28640 {
28641     struct
28642     {
28643         PTR32 commandBuffer;
28644         uint32_t groupCountX;
28645         uint32_t groupCountY;
28646         uint32_t groupCountZ;
28647     } *params = args;
28648
28649     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMeshTasksEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->groupCountX, params->groupCountY, params->groupCountZ);
28650 }
28651
28652 #ifdef _WIN64
28653 static void thunk64_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
28654 {
28655     struct vkCmdDrawMeshTasksIndirectCountEXT_params *params = args;
28656
28657     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);
28658 }
28659 #endif /* _WIN64 */
28660
28661 static void thunk32_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
28662 {
28663     struct
28664     {
28665         PTR32 commandBuffer;
28666         VkBuffer DECLSPEC_ALIGN(8) buffer;
28667         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28668         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
28669         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
28670         uint32_t maxDrawCount;
28671         uint32_t stride;
28672     } *params = args;
28673
28674     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMeshTasksIndirectCountEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
28675 }
28676
28677 #ifdef _WIN64
28678 static void thunk64_vkCmdDrawMeshTasksIndirectCountNV(void *args)
28679 {
28680     struct vkCmdDrawMeshTasksIndirectCountNV_params *params = args;
28681
28682     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);
28683 }
28684 #endif /* _WIN64 */
28685
28686 static void thunk32_vkCmdDrawMeshTasksIndirectCountNV(void *args)
28687 {
28688     struct
28689     {
28690         PTR32 commandBuffer;
28691         VkBuffer DECLSPEC_ALIGN(8) buffer;
28692         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28693         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
28694         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
28695         uint32_t maxDrawCount;
28696         uint32_t stride;
28697     } *params = args;
28698
28699     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMeshTasksIndirectCountNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
28700 }
28701
28702 #ifdef _WIN64
28703 static void thunk64_vkCmdDrawMeshTasksIndirectEXT(void *args)
28704 {
28705     struct vkCmdDrawMeshTasksIndirectEXT_params *params = args;
28706
28707     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);
28708 }
28709 #endif /* _WIN64 */
28710
28711 static void thunk32_vkCmdDrawMeshTasksIndirectEXT(void *args)
28712 {
28713     struct
28714     {
28715         PTR32 commandBuffer;
28716         VkBuffer DECLSPEC_ALIGN(8) buffer;
28717         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28718         uint32_t drawCount;
28719         uint32_t stride;
28720     } *params = args;
28721
28722     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMeshTasksIndirectEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
28723 }
28724
28725 #ifdef _WIN64
28726 static void thunk64_vkCmdDrawMeshTasksIndirectNV(void *args)
28727 {
28728     struct vkCmdDrawMeshTasksIndirectNV_params *params = args;
28729
28730     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);
28731 }
28732 #endif /* _WIN64 */
28733
28734 static void thunk32_vkCmdDrawMeshTasksIndirectNV(void *args)
28735 {
28736     struct
28737     {
28738         PTR32 commandBuffer;
28739         VkBuffer DECLSPEC_ALIGN(8) buffer;
28740         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28741         uint32_t drawCount;
28742         uint32_t stride;
28743     } *params = args;
28744
28745     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMeshTasksIndirectNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
28746 }
28747
28748 #ifdef _WIN64
28749 static void thunk64_vkCmdDrawMeshTasksNV(void *args)
28750 {
28751     struct vkCmdDrawMeshTasksNV_params *params = args;
28752
28753     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->taskCount, params->firstTask);
28754 }
28755 #endif /* _WIN64 */
28756
28757 static void thunk32_vkCmdDrawMeshTasksNV(void *args)
28758 {
28759     struct
28760     {
28761         PTR32 commandBuffer;
28762         uint32_t taskCount;
28763         uint32_t firstTask;
28764     } *params = args;
28765
28766     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMeshTasksNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->taskCount, params->firstTask);
28767 }
28768
28769 #ifdef _WIN64
28770 static void thunk64_vkCmdDrawMultiEXT(void *args)
28771 {
28772     struct vkCmdDrawMultiEXT_params *params = args;
28773
28774     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);
28775 }
28776 #endif /* _WIN64 */
28777
28778 static void thunk32_vkCmdDrawMultiEXT(void *args)
28779 {
28780     struct
28781     {
28782         PTR32 commandBuffer;
28783         uint32_t drawCount;
28784         PTR32 pVertexInfo;
28785         uint32_t instanceCount;
28786         uint32_t firstInstance;
28787         uint32_t stride;
28788     } *params = args;
28789
28790     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMultiEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->drawCount, (const VkMultiDrawInfoEXT *)UlongToPtr(params->pVertexInfo), params->instanceCount, params->firstInstance, params->stride);
28791 }
28792
28793 #ifdef _WIN64
28794 static void thunk64_vkCmdDrawMultiIndexedEXT(void *args)
28795 {
28796     struct vkCmdDrawMultiIndexedEXT_params *params = args;
28797
28798     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);
28799 }
28800 #endif /* _WIN64 */
28801
28802 static void thunk32_vkCmdDrawMultiIndexedEXT(void *args)
28803 {
28804     struct
28805     {
28806         PTR32 commandBuffer;
28807         uint32_t drawCount;
28808         PTR32 pIndexInfo;
28809         uint32_t instanceCount;
28810         uint32_t firstInstance;
28811         uint32_t stride;
28812         PTR32 pVertexOffset;
28813     } *params = args;
28814
28815     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMultiIndexedEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->drawCount, (const VkMultiDrawIndexedInfoEXT *)UlongToPtr(params->pIndexInfo), params->instanceCount, params->firstInstance, params->stride, (const int32_t *)UlongToPtr(params->pVertexOffset));
28816 }
28817
28818 #ifdef _WIN64
28819 static void thunk64_vkCmdEndConditionalRenderingEXT(void *args)
28820 {
28821     struct vkCmdEndConditionalRenderingEXT_params *params = args;
28822
28823     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
28824 }
28825 #endif /* _WIN64 */
28826
28827 static void thunk32_vkCmdEndConditionalRenderingEXT(void *args)
28828 {
28829     struct
28830     {
28831         PTR32 commandBuffer;
28832     } *params = args;
28833
28834     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndConditionalRenderingEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
28835 }
28836
28837 #ifdef _WIN64
28838 static void thunk64_vkCmdEndDebugUtilsLabelEXT(void *args)
28839 {
28840     struct vkCmdEndDebugUtilsLabelEXT_params *params = args;
28841
28842     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
28843 }
28844 #endif /* _WIN64 */
28845
28846 static void thunk32_vkCmdEndDebugUtilsLabelEXT(void *args)
28847 {
28848     struct
28849     {
28850         PTR32 commandBuffer;
28851     } *params = args;
28852
28853     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
28854 }
28855
28856 #ifdef _WIN64
28857 static void thunk64_vkCmdEndQuery(void *args)
28858 {
28859     struct vkCmdEndQuery_params *params = args;
28860
28861     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndQuery(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query);
28862 }
28863 #endif /* _WIN64 */
28864
28865 static void thunk32_vkCmdEndQuery(void *args)
28866 {
28867     struct
28868     {
28869         PTR32 commandBuffer;
28870         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
28871         uint32_t query;
28872     } *params = args;
28873
28874     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndQuery(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->queryPool, params->query);
28875 }
28876
28877 #ifdef _WIN64
28878 static void thunk64_vkCmdEndQueryIndexedEXT(void *args)
28879 {
28880     struct vkCmdEndQueryIndexedEXT_params *params = args;
28881
28882     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);
28883 }
28884 #endif /* _WIN64 */
28885
28886 static void thunk32_vkCmdEndQueryIndexedEXT(void *args)
28887 {
28888     struct
28889     {
28890         PTR32 commandBuffer;
28891         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
28892         uint32_t query;
28893         uint32_t index;
28894     } *params = args;
28895
28896     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndQueryIndexedEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->queryPool, params->query, params->index);
28897 }
28898
28899 #ifdef _WIN64
28900 static void thunk64_vkCmdEndRenderPass(void *args)
28901 {
28902     struct vkCmdEndRenderPass_params *params = args;
28903
28904     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
28905 }
28906 #endif /* _WIN64 */
28907
28908 static void thunk32_vkCmdEndRenderPass(void *args)
28909 {
28910     struct
28911     {
28912         PTR32 commandBuffer;
28913     } *params = args;
28914
28915     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderPass(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
28916 }
28917
28918 #ifdef _WIN64
28919 static void thunk64_vkCmdEndRenderPass2(void *args)
28920 {
28921     struct vkCmdEndRenderPass2_params *params = args;
28922
28923     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassEndInfo);
28924 }
28925 #endif /* _WIN64 */
28926
28927 static void thunk32_vkCmdEndRenderPass2(void *args)
28928 {
28929     struct
28930     {
28931         PTR32 commandBuffer;
28932         PTR32 pSubpassEndInfo;
28933     } *params = args;
28934     VkSubpassEndInfo pSubpassEndInfo_host;
28935     struct conversion_context ctx;
28936
28937     init_conversion_context(&ctx);
28938     convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
28939     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderPass2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pSubpassEndInfo_host);
28940     free_conversion_context(&ctx);
28941 }
28942
28943 #ifdef _WIN64
28944 static void thunk64_vkCmdEndRenderPass2KHR(void *args)
28945 {
28946     struct vkCmdEndRenderPass2KHR_params *params = args;
28947
28948     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassEndInfo);
28949 }
28950 #endif /* _WIN64 */
28951
28952 static void thunk32_vkCmdEndRenderPass2KHR(void *args)
28953 {
28954     struct
28955     {
28956         PTR32 commandBuffer;
28957         PTR32 pSubpassEndInfo;
28958     } *params = args;
28959     VkSubpassEndInfo pSubpassEndInfo_host;
28960     struct conversion_context ctx;
28961
28962     init_conversion_context(&ctx);
28963     convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
28964     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderPass2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pSubpassEndInfo_host);
28965     free_conversion_context(&ctx);
28966 }
28967
28968 #ifdef _WIN64
28969 static void thunk64_vkCmdEndRendering(void *args)
28970 {
28971     struct vkCmdEndRendering_params *params = args;
28972
28973     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
28974 }
28975 #endif /* _WIN64 */
28976
28977 static void thunk32_vkCmdEndRendering(void *args)
28978 {
28979     struct
28980     {
28981         PTR32 commandBuffer;
28982     } *params = args;
28983
28984     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRendering(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
28985 }
28986
28987 #ifdef _WIN64
28988 static void thunk64_vkCmdEndRenderingKHR(void *args)
28989 {
28990     struct vkCmdEndRenderingKHR_params *params = args;
28991
28992     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
28993 }
28994 #endif /* _WIN64 */
28995
28996 static void thunk32_vkCmdEndRenderingKHR(void *args)
28997 {
28998     struct
28999     {
29000         PTR32 commandBuffer;
29001     } *params = args;
29002
29003     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderingKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
29004 }
29005
29006 #ifdef _WIN64
29007 static void thunk64_vkCmdEndTransformFeedbackEXT(void *args)
29008 {
29009     struct vkCmdEndTransformFeedbackEXT_params *params = args;
29010
29011     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);
29012 }
29013 #endif /* _WIN64 */
29014
29015 static void thunk32_vkCmdEndTransformFeedbackEXT(void *args)
29016 {
29017     struct
29018     {
29019         PTR32 commandBuffer;
29020         uint32_t firstCounterBuffer;
29021         uint32_t counterBufferCount;
29022         PTR32 pCounterBuffers;
29023         PTR32 pCounterBufferOffsets;
29024     } *params = args;
29025
29026     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndTransformFeedbackEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstCounterBuffer, params->counterBufferCount, (const VkBuffer *)UlongToPtr(params->pCounterBuffers), (const VkDeviceSize *)UlongToPtr(params->pCounterBufferOffsets));
29027 }
29028
29029 #ifdef _WIN64
29030 static void thunk64_vkCmdExecuteCommands(void *args)
29031 {
29032     struct vkCmdExecuteCommands_params *params = args;
29033     const VkCommandBuffer *pCommandBuffers_host;
29034     struct conversion_context ctx;
29035
29036     init_conversion_context(&ctx);
29037     pCommandBuffers_host = convert_VkCommandBuffer_array_win64_to_host(&ctx, params->pCommandBuffers, params->commandBufferCount);
29038     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteCommands(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->commandBufferCount, pCommandBuffers_host);
29039     free_conversion_context(&ctx);
29040 }
29041 #endif /* _WIN64 */
29042
29043 static void thunk32_vkCmdExecuteCommands(void *args)
29044 {
29045     struct
29046     {
29047         PTR32 commandBuffer;
29048         uint32_t commandBufferCount;
29049         PTR32 pCommandBuffers;
29050     } *params = args;
29051     const VkCommandBuffer *pCommandBuffers_host;
29052     struct conversion_context ctx;
29053
29054     init_conversion_context(&ctx);
29055     pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_host(&ctx, (const PTR32 *)UlongToPtr(params->pCommandBuffers), params->commandBufferCount);
29056     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdExecuteCommands(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->commandBufferCount, pCommandBuffers_host);
29057     free_conversion_context(&ctx);
29058 }
29059
29060 #ifdef _WIN64
29061 static void thunk64_vkCmdExecuteGeneratedCommandsNV(void *args)
29062 {
29063     struct vkCmdExecuteGeneratedCommandsNV_params *params = args;
29064
29065     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->isPreprocessed, params->pGeneratedCommandsInfo);
29066 }
29067 #endif /* _WIN64 */
29068
29069 static void thunk32_vkCmdExecuteGeneratedCommandsNV(void *args)
29070 {
29071     struct
29072     {
29073         PTR32 commandBuffer;
29074         VkBool32 isPreprocessed;
29075         PTR32 pGeneratedCommandsInfo;
29076     } *params = args;
29077     VkGeneratedCommandsInfoNV pGeneratedCommandsInfo_host;
29078     struct conversion_context ctx;
29079
29080     init_conversion_context(&ctx);
29081     convert_VkGeneratedCommandsInfoNV_win32_to_host(&ctx, (const VkGeneratedCommandsInfoNV32 *)UlongToPtr(params->pGeneratedCommandsInfo), &pGeneratedCommandsInfo_host);
29082     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdExecuteGeneratedCommandsNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->isPreprocessed, &pGeneratedCommandsInfo_host);
29083     free_conversion_context(&ctx);
29084 }
29085
29086 #ifdef _WIN64
29087 static void thunk64_vkCmdFillBuffer(void *args)
29088 {
29089     struct vkCmdFillBuffer_params *params = args;
29090
29091     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);
29092 }
29093 #endif /* _WIN64 */
29094
29095 static void thunk32_vkCmdFillBuffer(void *args)
29096 {
29097     struct
29098     {
29099         PTR32 commandBuffer;
29100         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
29101         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
29102         VkDeviceSize DECLSPEC_ALIGN(8) size;
29103         uint32_t data;
29104     } *params = args;
29105
29106     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdFillBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->dstBuffer, params->dstOffset, params->size, params->data);
29107 }
29108
29109 #ifdef _WIN64
29110 static void thunk64_vkCmdInsertDebugUtilsLabelEXT(void *args)
29111 {
29112     struct vkCmdInsertDebugUtilsLabelEXT_params *params = args;
29113
29114     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdInsertDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLabelInfo);
29115 }
29116 #endif /* _WIN64 */
29117
29118 static void thunk32_vkCmdInsertDebugUtilsLabelEXT(void *args)
29119 {
29120     struct
29121     {
29122         PTR32 commandBuffer;
29123         PTR32 pLabelInfo;
29124     } *params = args;
29125     VkDebugUtilsLabelEXT pLabelInfo_host;
29126
29127     convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
29128     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdInsertDebugUtilsLabelEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pLabelInfo_host);
29129 }
29130
29131 #ifdef _WIN64
29132 static void thunk64_vkCmdNextSubpass(void *args)
29133 {
29134     struct vkCmdNextSubpass_params *params = args;
29135
29136     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->contents);
29137 }
29138 #endif /* _WIN64 */
29139
29140 static void thunk32_vkCmdNextSubpass(void *args)
29141 {
29142     struct
29143     {
29144         PTR32 commandBuffer;
29145         VkSubpassContents contents;
29146     } *params = args;
29147
29148     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdNextSubpass(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->contents);
29149 }
29150
29151 #ifdef _WIN64
29152 static void thunk64_vkCmdNextSubpass2(void *args)
29153 {
29154     struct vkCmdNextSubpass2_params *params = args;
29155
29156     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
29157 }
29158 #endif /* _WIN64 */
29159
29160 static void thunk32_vkCmdNextSubpass2(void *args)
29161 {
29162     struct
29163     {
29164         PTR32 commandBuffer;
29165         PTR32 pSubpassBeginInfo;
29166         PTR32 pSubpassEndInfo;
29167     } *params = args;
29168     VkSubpassBeginInfo pSubpassBeginInfo_host;
29169     VkSubpassEndInfo pSubpassEndInfo_host;
29170     struct conversion_context ctx;
29171
29172     init_conversion_context(&ctx);
29173     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
29174     convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
29175     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdNextSubpass2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pSubpassBeginInfo_host, &pSubpassEndInfo_host);
29176     free_conversion_context(&ctx);
29177 }
29178
29179 #ifdef _WIN64
29180 static void thunk64_vkCmdNextSubpass2KHR(void *args)
29181 {
29182     struct vkCmdNextSubpass2KHR_params *params = args;
29183
29184     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
29185 }
29186 #endif /* _WIN64 */
29187
29188 static void thunk32_vkCmdNextSubpass2KHR(void *args)
29189 {
29190     struct
29191     {
29192         PTR32 commandBuffer;
29193         PTR32 pSubpassBeginInfo;
29194         PTR32 pSubpassEndInfo;
29195     } *params = args;
29196     VkSubpassBeginInfo pSubpassBeginInfo_host;
29197     VkSubpassEndInfo pSubpassEndInfo_host;
29198     struct conversion_context ctx;
29199
29200     init_conversion_context(&ctx);
29201     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
29202     convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
29203     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdNextSubpass2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pSubpassBeginInfo_host, &pSubpassEndInfo_host);
29204     free_conversion_context(&ctx);
29205 }
29206
29207 #ifdef _WIN64
29208 static void thunk64_vkCmdOpticalFlowExecuteNV(void *args)
29209 {
29210     struct vkCmdOpticalFlowExecuteNV_params *params = args;
29211
29212     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdOpticalFlowExecuteNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->session, params->pExecuteInfo);
29213 }
29214 #endif /* _WIN64 */
29215
29216 static void thunk32_vkCmdOpticalFlowExecuteNV(void *args)
29217 {
29218     struct
29219     {
29220         PTR32 commandBuffer;
29221         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
29222         PTR32 pExecuteInfo;
29223     } *params = args;
29224     VkOpticalFlowExecuteInfoNV pExecuteInfo_host;
29225
29226     convert_VkOpticalFlowExecuteInfoNV_win32_to_host((const VkOpticalFlowExecuteInfoNV32 *)UlongToPtr(params->pExecuteInfo), &pExecuteInfo_host);
29227     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdOpticalFlowExecuteNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->session, &pExecuteInfo_host);
29228 }
29229
29230 #ifdef _WIN64
29231 static void thunk64_vkCmdPipelineBarrier(void *args)
29232 {
29233     struct vkCmdPipelineBarrier_params *params = args;
29234
29235     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);
29236 }
29237 #endif /* _WIN64 */
29238
29239 static void thunk32_vkCmdPipelineBarrier(void *args)
29240 {
29241     struct
29242     {
29243         PTR32 commandBuffer;
29244         VkPipelineStageFlags srcStageMask;
29245         VkPipelineStageFlags dstStageMask;
29246         VkDependencyFlags dependencyFlags;
29247         uint32_t memoryBarrierCount;
29248         PTR32 pMemoryBarriers;
29249         uint32_t bufferMemoryBarrierCount;
29250         PTR32 pBufferMemoryBarriers;
29251         uint32_t imageMemoryBarrierCount;
29252         PTR32 pImageMemoryBarriers;
29253     } *params = args;
29254     const VkMemoryBarrier *pMemoryBarriers_host;
29255     const VkBufferMemoryBarrier *pBufferMemoryBarriers_host;
29256     const VkImageMemoryBarrier *pImageMemoryBarriers_host;
29257     struct conversion_context ctx;
29258
29259     init_conversion_context(&ctx);
29260     pMemoryBarriers_host = convert_VkMemoryBarrier_array_win32_to_host(&ctx, (const VkMemoryBarrier32 *)UlongToPtr(params->pMemoryBarriers), params->memoryBarrierCount);
29261     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win32_to_host(&ctx, (const VkBufferMemoryBarrier32 *)UlongToPtr(params->pBufferMemoryBarriers), params->bufferMemoryBarrierCount);
29262     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win32_to_host(&ctx, (const VkImageMemoryBarrier32 *)UlongToPtr(params->pImageMemoryBarriers), params->imageMemoryBarrierCount);
29263     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPipelineBarrier(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcStageMask, params->dstStageMask, params->dependencyFlags, params->memoryBarrierCount, pMemoryBarriers_host, params->bufferMemoryBarrierCount, pBufferMemoryBarriers_host, params->imageMemoryBarrierCount, pImageMemoryBarriers_host);
29264     free_conversion_context(&ctx);
29265 }
29266
29267 #ifdef _WIN64
29268 static void thunk64_vkCmdPipelineBarrier2(void *args)
29269 {
29270     struct vkCmdPipelineBarrier2_params *params = args;
29271
29272     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pDependencyInfo);
29273 }
29274 #endif /* _WIN64 */
29275
29276 static void thunk32_vkCmdPipelineBarrier2(void *args)
29277 {
29278     struct
29279     {
29280         PTR32 commandBuffer;
29281         PTR32 pDependencyInfo;
29282     } *params = args;
29283     VkDependencyInfo pDependencyInfo_host;
29284     struct conversion_context ctx;
29285
29286     init_conversion_context(&ctx);
29287     convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
29288     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPipelineBarrier2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pDependencyInfo_host);
29289     free_conversion_context(&ctx);
29290 }
29291
29292 #ifdef _WIN64
29293 static void thunk64_vkCmdPipelineBarrier2KHR(void *args)
29294 {
29295     struct vkCmdPipelineBarrier2KHR_params *params = args;
29296
29297     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pDependencyInfo);
29298 }
29299 #endif /* _WIN64 */
29300
29301 static void thunk32_vkCmdPipelineBarrier2KHR(void *args)
29302 {
29303     struct
29304     {
29305         PTR32 commandBuffer;
29306         PTR32 pDependencyInfo;
29307     } *params = args;
29308     VkDependencyInfo pDependencyInfo_host;
29309     struct conversion_context ctx;
29310
29311     init_conversion_context(&ctx);
29312     convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
29313     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPipelineBarrier2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pDependencyInfo_host);
29314     free_conversion_context(&ctx);
29315 }
29316
29317 #ifdef _WIN64
29318 static void thunk64_vkCmdPreprocessGeneratedCommandsNV(void *args)
29319 {
29320     struct vkCmdPreprocessGeneratedCommandsNV_params *params = args;
29321
29322     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPreprocessGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pGeneratedCommandsInfo);
29323 }
29324 #endif /* _WIN64 */
29325
29326 static void thunk32_vkCmdPreprocessGeneratedCommandsNV(void *args)
29327 {
29328     struct
29329     {
29330         PTR32 commandBuffer;
29331         PTR32 pGeneratedCommandsInfo;
29332     } *params = args;
29333     VkGeneratedCommandsInfoNV pGeneratedCommandsInfo_host;
29334     struct conversion_context ctx;
29335
29336     init_conversion_context(&ctx);
29337     convert_VkGeneratedCommandsInfoNV_win32_to_host(&ctx, (const VkGeneratedCommandsInfoNV32 *)UlongToPtr(params->pGeneratedCommandsInfo), &pGeneratedCommandsInfo_host);
29338     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPreprocessGeneratedCommandsNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pGeneratedCommandsInfo_host);
29339     free_conversion_context(&ctx);
29340 }
29341
29342 #ifdef _WIN64
29343 static void thunk64_vkCmdPushConstants(void *args)
29344 {
29345     struct vkCmdPushConstants_params *params = args;
29346
29347     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);
29348 }
29349 #endif /* _WIN64 */
29350
29351 static void thunk32_vkCmdPushConstants(void *args)
29352 {
29353     struct
29354     {
29355         PTR32 commandBuffer;
29356         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
29357         VkShaderStageFlags stageFlags;
29358         uint32_t offset;
29359         uint32_t size;
29360         PTR32 pValues;
29361     } *params = args;
29362
29363     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPushConstants(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->layout, params->stageFlags, params->offset, params->size, (const void *)UlongToPtr(params->pValues));
29364 }
29365
29366 #ifdef _WIN64
29367 static void thunk64_vkCmdPushDescriptorSetKHR(void *args)
29368 {
29369     struct vkCmdPushDescriptorSetKHR_params *params = args;
29370
29371     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);
29372 }
29373 #endif /* _WIN64 */
29374
29375 static void thunk32_vkCmdPushDescriptorSetKHR(void *args)
29376 {
29377     struct
29378     {
29379         PTR32 commandBuffer;
29380         VkPipelineBindPoint pipelineBindPoint;
29381         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
29382         uint32_t set;
29383         uint32_t descriptorWriteCount;
29384         PTR32 pDescriptorWrites;
29385     } *params = args;
29386     const VkWriteDescriptorSet *pDescriptorWrites_host;
29387     struct conversion_context ctx;
29388
29389     init_conversion_context(&ctx);
29390     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win32_to_host(&ctx, (const VkWriteDescriptorSet32 *)UlongToPtr(params->pDescriptorWrites), params->descriptorWriteCount);
29391     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPushDescriptorSetKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->layout, params->set, params->descriptorWriteCount, pDescriptorWrites_host);
29392     free_conversion_context(&ctx);
29393 }
29394
29395 #ifdef _WIN64
29396 static void thunk64_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
29397 {
29398     struct vkCmdPushDescriptorSetWithTemplateKHR_params *params = args;
29399
29400     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);
29401 }
29402 #endif /* _WIN64 */
29403
29404 static void thunk32_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
29405 {
29406     struct
29407     {
29408         PTR32 commandBuffer;
29409         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
29410         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
29411         uint32_t set;
29412         PTR32 pData;
29413     } *params = args;
29414
29415     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPushDescriptorSetWithTemplateKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->descriptorUpdateTemplate, params->layout, params->set, (const void *)UlongToPtr(params->pData));
29416 }
29417
29418 #ifdef _WIN64
29419 static void thunk64_vkCmdResetEvent(void *args)
29420 {
29421     struct vkCmdResetEvent_params *params = args;
29422
29423     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
29424 }
29425 #endif /* _WIN64 */
29426
29427 static void thunk32_vkCmdResetEvent(void *args)
29428 {
29429     struct
29430     {
29431         PTR32 commandBuffer;
29432         VkEvent DECLSPEC_ALIGN(8) event;
29433         VkPipelineStageFlags stageMask;
29434     } *params = args;
29435
29436     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResetEvent(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, params->stageMask);
29437 }
29438
29439 #ifdef _WIN64
29440 static void thunk64_vkCmdResetEvent2(void *args)
29441 {
29442     struct vkCmdResetEvent2_params *params = args;
29443
29444     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
29445 }
29446 #endif /* _WIN64 */
29447
29448 static void thunk32_vkCmdResetEvent2(void *args)
29449 {
29450     struct
29451     {
29452         PTR32 commandBuffer;
29453         VkEvent DECLSPEC_ALIGN(8) event;
29454         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
29455     } *params = args;
29456
29457     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResetEvent2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, params->stageMask);
29458 }
29459
29460 #ifdef _WIN64
29461 static void thunk64_vkCmdResetEvent2KHR(void *args)
29462 {
29463     struct vkCmdResetEvent2KHR_params *params = args;
29464
29465     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
29466 }
29467 #endif /* _WIN64 */
29468
29469 static void thunk32_vkCmdResetEvent2KHR(void *args)
29470 {
29471     struct
29472     {
29473         PTR32 commandBuffer;
29474         VkEvent DECLSPEC_ALIGN(8) event;
29475         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
29476     } *params = args;
29477
29478     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResetEvent2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, params->stageMask);
29479 }
29480
29481 #ifdef _WIN64
29482 static void thunk64_vkCmdResetQueryPool(void *args)
29483 {
29484     struct vkCmdResetQueryPool_params *params = args;
29485
29486     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);
29487 }
29488 #endif /* _WIN64 */
29489
29490 static void thunk32_vkCmdResetQueryPool(void *args)
29491 {
29492     struct
29493     {
29494         PTR32 commandBuffer;
29495         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
29496         uint32_t firstQuery;
29497         uint32_t queryCount;
29498     } *params = args;
29499
29500     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResetQueryPool(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->queryPool, params->firstQuery, params->queryCount);
29501 }
29502
29503 #ifdef _WIN64
29504 static void thunk64_vkCmdResolveImage(void *args)
29505 {
29506     struct vkCmdResolveImage_params *params = args;
29507
29508     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);
29509 }
29510 #endif /* _WIN64 */
29511
29512 static void thunk32_vkCmdResolveImage(void *args)
29513 {
29514     struct
29515     {
29516         PTR32 commandBuffer;
29517         VkImage DECLSPEC_ALIGN(8) srcImage;
29518         VkImageLayout srcImageLayout;
29519         VkImage DECLSPEC_ALIGN(8) dstImage;
29520         VkImageLayout dstImageLayout;
29521         uint32_t regionCount;
29522         PTR32 pRegions;
29523     } *params = args;
29524
29525     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResolveImage(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, (const VkImageResolve *)UlongToPtr(params->pRegions));
29526 }
29527
29528 #ifdef _WIN64
29529 static void thunk64_vkCmdResolveImage2(void *args)
29530 {
29531     struct vkCmdResolveImage2_params *params = args;
29532
29533     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pResolveImageInfo);
29534 }
29535 #endif /* _WIN64 */
29536
29537 static void thunk32_vkCmdResolveImage2(void *args)
29538 {
29539     struct
29540     {
29541         PTR32 commandBuffer;
29542         PTR32 pResolveImageInfo;
29543     } *params = args;
29544     VkResolveImageInfo2 pResolveImageInfo_host;
29545     struct conversion_context ctx;
29546
29547     init_conversion_context(&ctx);
29548     convert_VkResolveImageInfo2_win32_to_host(&ctx, (const VkResolveImageInfo232 *)UlongToPtr(params->pResolveImageInfo), &pResolveImageInfo_host);
29549     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResolveImage2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pResolveImageInfo_host);
29550     free_conversion_context(&ctx);
29551 }
29552
29553 #ifdef _WIN64
29554 static void thunk64_vkCmdResolveImage2KHR(void *args)
29555 {
29556     struct vkCmdResolveImage2KHR_params *params = args;
29557
29558     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pResolveImageInfo);
29559 }
29560 #endif /* _WIN64 */
29561
29562 static void thunk32_vkCmdResolveImage2KHR(void *args)
29563 {
29564     struct
29565     {
29566         PTR32 commandBuffer;
29567         PTR32 pResolveImageInfo;
29568     } *params = args;
29569     VkResolveImageInfo2 pResolveImageInfo_host;
29570     struct conversion_context ctx;
29571
29572     init_conversion_context(&ctx);
29573     convert_VkResolveImageInfo2_win32_to_host(&ctx, (const VkResolveImageInfo232 *)UlongToPtr(params->pResolveImageInfo), &pResolveImageInfo_host);
29574     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResolveImage2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pResolveImageInfo_host);
29575     free_conversion_context(&ctx);
29576 }
29577
29578 #ifdef _WIN64
29579 static void thunk64_vkCmdSetAlphaToCoverageEnableEXT(void *args)
29580 {
29581     struct vkCmdSetAlphaToCoverageEnableEXT_params *params = args;
29582
29583     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToCoverageEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToCoverageEnable);
29584 }
29585 #endif /* _WIN64 */
29586
29587 static void thunk32_vkCmdSetAlphaToCoverageEnableEXT(void *args)
29588 {
29589     struct
29590     {
29591         PTR32 commandBuffer;
29592         VkBool32 alphaToCoverageEnable;
29593     } *params = args;
29594
29595     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetAlphaToCoverageEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->alphaToCoverageEnable);
29596 }
29597
29598 #ifdef _WIN64
29599 static void thunk64_vkCmdSetAlphaToOneEnableEXT(void *args)
29600 {
29601     struct vkCmdSetAlphaToOneEnableEXT_params *params = args;
29602
29603     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToOneEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToOneEnable);
29604 }
29605 #endif /* _WIN64 */
29606
29607 static void thunk32_vkCmdSetAlphaToOneEnableEXT(void *args)
29608 {
29609     struct
29610     {
29611         PTR32 commandBuffer;
29612         VkBool32 alphaToOneEnable;
29613     } *params = args;
29614
29615     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetAlphaToOneEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->alphaToOneEnable);
29616 }
29617
29618 #ifdef _WIN64
29619 static void thunk64_vkCmdSetAttachmentFeedbackLoopEnableEXT(void *args)
29620 {
29621     struct vkCmdSetAttachmentFeedbackLoopEnableEXT_params *params = args;
29622
29623     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAttachmentFeedbackLoopEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->aspectMask);
29624 }
29625 #endif /* _WIN64 */
29626
29627 static void thunk32_vkCmdSetAttachmentFeedbackLoopEnableEXT(void *args)
29628 {
29629     struct
29630     {
29631         PTR32 commandBuffer;
29632         VkImageAspectFlags aspectMask;
29633     } *params = args;
29634
29635     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetAttachmentFeedbackLoopEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->aspectMask);
29636 }
29637
29638 #ifdef _WIN64
29639 static void thunk64_vkCmdSetBlendConstants(void *args)
29640 {
29641     struct vkCmdSetBlendConstants_params *params = args;
29642
29643     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetBlendConstants(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->blendConstants);
29644 }
29645 #endif /* _WIN64 */
29646
29647 static void thunk32_vkCmdSetBlendConstants(void *args)
29648 {
29649     struct
29650     {
29651         PTR32 commandBuffer;
29652         PTR32 blendConstants;
29653     } *params = args;
29654
29655     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetBlendConstants(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, (const float *)UlongToPtr(params->blendConstants));
29656 }
29657
29658 #ifdef _WIN64
29659 static void thunk64_vkCmdSetCheckpointNV(void *args)
29660 {
29661     struct vkCmdSetCheckpointNV_params *params = args;
29662
29663     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCheckpointNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCheckpointMarker);
29664 }
29665 #endif /* _WIN64 */
29666
29667 static void thunk32_vkCmdSetCheckpointNV(void *args)
29668 {
29669     struct
29670     {
29671         PTR32 commandBuffer;
29672         PTR32 pCheckpointMarker;
29673     } *params = args;
29674
29675     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCheckpointNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, (const void *)UlongToPtr(params->pCheckpointMarker));
29676 }
29677
29678 #ifdef _WIN64
29679 static void thunk64_vkCmdSetCoarseSampleOrderNV(void *args)
29680 {
29681     struct vkCmdSetCoarseSampleOrderNV_params *params = args;
29682
29683     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);
29684 }
29685 #endif /* _WIN64 */
29686
29687 static void thunk32_vkCmdSetCoarseSampleOrderNV(void *args)
29688 {
29689     struct
29690     {
29691         PTR32 commandBuffer;
29692         VkCoarseSampleOrderTypeNV sampleOrderType;
29693         uint32_t customSampleOrderCount;
29694         PTR32 pCustomSampleOrders;
29695     } *params = args;
29696     const VkCoarseSampleOrderCustomNV *pCustomSampleOrders_host;
29697     struct conversion_context ctx;
29698
29699     init_conversion_context(&ctx);
29700     pCustomSampleOrders_host = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(&ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(params->pCustomSampleOrders), params->customSampleOrderCount);
29701     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoarseSampleOrderNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->sampleOrderType, params->customSampleOrderCount, pCustomSampleOrders_host);
29702     free_conversion_context(&ctx);
29703 }
29704
29705 #ifdef _WIN64
29706 static void thunk64_vkCmdSetColorBlendAdvancedEXT(void *args)
29707 {
29708     struct vkCmdSetColorBlendAdvancedEXT_params *params = args;
29709
29710     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);
29711 }
29712 #endif /* _WIN64 */
29713
29714 static void thunk32_vkCmdSetColorBlendAdvancedEXT(void *args)
29715 {
29716     struct
29717     {
29718         PTR32 commandBuffer;
29719         uint32_t firstAttachment;
29720         uint32_t attachmentCount;
29721         PTR32 pColorBlendAdvanced;
29722     } *params = args;
29723
29724     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorBlendAdvancedEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstAttachment, params->attachmentCount, (const VkColorBlendAdvancedEXT *)UlongToPtr(params->pColorBlendAdvanced));
29725 }
29726
29727 #ifdef _WIN64
29728 static void thunk64_vkCmdSetColorBlendEnableEXT(void *args)
29729 {
29730     struct vkCmdSetColorBlendEnableEXT_params *params = args;
29731
29732     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);
29733 }
29734 #endif /* _WIN64 */
29735
29736 static void thunk32_vkCmdSetColorBlendEnableEXT(void *args)
29737 {
29738     struct
29739     {
29740         PTR32 commandBuffer;
29741         uint32_t firstAttachment;
29742         uint32_t attachmentCount;
29743         PTR32 pColorBlendEnables;
29744     } *params = args;
29745
29746     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorBlendEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstAttachment, params->attachmentCount, (const VkBool32 *)UlongToPtr(params->pColorBlendEnables));
29747 }
29748
29749 #ifdef _WIN64
29750 static void thunk64_vkCmdSetColorBlendEquationEXT(void *args)
29751 {
29752     struct vkCmdSetColorBlendEquationEXT_params *params = args;
29753
29754     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);
29755 }
29756 #endif /* _WIN64 */
29757
29758 static void thunk32_vkCmdSetColorBlendEquationEXT(void *args)
29759 {
29760     struct
29761     {
29762         PTR32 commandBuffer;
29763         uint32_t firstAttachment;
29764         uint32_t attachmentCount;
29765         PTR32 pColorBlendEquations;
29766     } *params = args;
29767
29768     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorBlendEquationEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstAttachment, params->attachmentCount, (const VkColorBlendEquationEXT *)UlongToPtr(params->pColorBlendEquations));
29769 }
29770
29771 #ifdef _WIN64
29772 static void thunk64_vkCmdSetColorWriteEnableEXT(void *args)
29773 {
29774     struct vkCmdSetColorWriteEnableEXT_params *params = args;
29775
29776     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pColorWriteEnables);
29777 }
29778 #endif /* _WIN64 */
29779
29780 static void thunk32_vkCmdSetColorWriteEnableEXT(void *args)
29781 {
29782     struct
29783     {
29784         PTR32 commandBuffer;
29785         uint32_t attachmentCount;
29786         PTR32 pColorWriteEnables;
29787     } *params = args;
29788
29789     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorWriteEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->attachmentCount, (const VkBool32 *)UlongToPtr(params->pColorWriteEnables));
29790 }
29791
29792 #ifdef _WIN64
29793 static void thunk64_vkCmdSetColorWriteMaskEXT(void *args)
29794 {
29795     struct vkCmdSetColorWriteMaskEXT_params *params = args;
29796
29797     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);
29798 }
29799 #endif /* _WIN64 */
29800
29801 static void thunk32_vkCmdSetColorWriteMaskEXT(void *args)
29802 {
29803     struct
29804     {
29805         PTR32 commandBuffer;
29806         uint32_t firstAttachment;
29807         uint32_t attachmentCount;
29808         PTR32 pColorWriteMasks;
29809     } *params = args;
29810
29811     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorWriteMaskEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstAttachment, params->attachmentCount, (const VkColorComponentFlags *)UlongToPtr(params->pColorWriteMasks));
29812 }
29813
29814 #ifdef _WIN64
29815 static void thunk64_vkCmdSetConservativeRasterizationModeEXT(void *args)
29816 {
29817     struct vkCmdSetConservativeRasterizationModeEXT_params *params = args;
29818
29819     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetConservativeRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->conservativeRasterizationMode);
29820 }
29821 #endif /* _WIN64 */
29822
29823 static void thunk32_vkCmdSetConservativeRasterizationModeEXT(void *args)
29824 {
29825     struct
29826     {
29827         PTR32 commandBuffer;
29828         VkConservativeRasterizationModeEXT conservativeRasterizationMode;
29829     } *params = args;
29830
29831     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetConservativeRasterizationModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->conservativeRasterizationMode);
29832 }
29833
29834 #ifdef _WIN64
29835 static void thunk64_vkCmdSetCoverageModulationModeNV(void *args)
29836 {
29837     struct vkCmdSetCoverageModulationModeNV_params *params = args;
29838
29839     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationMode);
29840 }
29841 #endif /* _WIN64 */
29842
29843 static void thunk32_vkCmdSetCoverageModulationModeNV(void *args)
29844 {
29845     struct
29846     {
29847         PTR32 commandBuffer;
29848         VkCoverageModulationModeNV coverageModulationMode;
29849     } *params = args;
29850
29851     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageModulationModeNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageModulationMode);
29852 }
29853
29854 #ifdef _WIN64
29855 static void thunk64_vkCmdSetCoverageModulationTableEnableNV(void *args)
29856 {
29857     struct vkCmdSetCoverageModulationTableEnableNV_params *params = args;
29858
29859     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableEnable);
29860 }
29861 #endif /* _WIN64 */
29862
29863 static void thunk32_vkCmdSetCoverageModulationTableEnableNV(void *args)
29864 {
29865     struct
29866     {
29867         PTR32 commandBuffer;
29868         VkBool32 coverageModulationTableEnable;
29869     } *params = args;
29870
29871     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageModulationTableEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageModulationTableEnable);
29872 }
29873
29874 #ifdef _WIN64
29875 static void thunk64_vkCmdSetCoverageModulationTableNV(void *args)
29876 {
29877     struct vkCmdSetCoverageModulationTableNV_params *params = args;
29878
29879     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
29880 }
29881 #endif /* _WIN64 */
29882
29883 static void thunk32_vkCmdSetCoverageModulationTableNV(void *args)
29884 {
29885     struct
29886     {
29887         PTR32 commandBuffer;
29888         uint32_t coverageModulationTableCount;
29889         PTR32 pCoverageModulationTable;
29890     } *params = args;
29891
29892     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageModulationTableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageModulationTableCount, (const float *)UlongToPtr(params->pCoverageModulationTable));
29893 }
29894
29895 #ifdef _WIN64
29896 static void thunk64_vkCmdSetCoverageReductionModeNV(void *args)
29897 {
29898     struct vkCmdSetCoverageReductionModeNV_params *params = args;
29899
29900     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageReductionModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageReductionMode);
29901 }
29902 #endif /* _WIN64 */
29903
29904 static void thunk32_vkCmdSetCoverageReductionModeNV(void *args)
29905 {
29906     struct
29907     {
29908         PTR32 commandBuffer;
29909         VkCoverageReductionModeNV coverageReductionMode;
29910     } *params = args;
29911
29912     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageReductionModeNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageReductionMode);
29913 }
29914
29915 #ifdef _WIN64
29916 static void thunk64_vkCmdSetCoverageToColorEnableNV(void *args)
29917 {
29918     struct vkCmdSetCoverageToColorEnableNV_params *params = args;
29919
29920     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorEnable);
29921 }
29922 #endif /* _WIN64 */
29923
29924 static void thunk32_vkCmdSetCoverageToColorEnableNV(void *args)
29925 {
29926     struct
29927     {
29928         PTR32 commandBuffer;
29929         VkBool32 coverageToColorEnable;
29930     } *params = args;
29931
29932     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageToColorEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageToColorEnable);
29933 }
29934
29935 #ifdef _WIN64
29936 static void thunk64_vkCmdSetCoverageToColorLocationNV(void *args)
29937 {
29938     struct vkCmdSetCoverageToColorLocationNV_params *params = args;
29939
29940     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorLocationNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorLocation);
29941 }
29942 #endif /* _WIN64 */
29943
29944 static void thunk32_vkCmdSetCoverageToColorLocationNV(void *args)
29945 {
29946     struct
29947     {
29948         PTR32 commandBuffer;
29949         uint32_t coverageToColorLocation;
29950     } *params = args;
29951
29952     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageToColorLocationNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageToColorLocation);
29953 }
29954
29955 #ifdef _WIN64
29956 static void thunk64_vkCmdSetCullMode(void *args)
29957 {
29958     struct vkCmdSetCullMode_params *params = args;
29959
29960     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullMode(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
29961 }
29962 #endif /* _WIN64 */
29963
29964 static void thunk32_vkCmdSetCullMode(void *args)
29965 {
29966     struct
29967     {
29968         PTR32 commandBuffer;
29969         VkCullModeFlags cullMode;
29970     } *params = args;
29971
29972     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCullMode(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->cullMode);
29973 }
29974
29975 #ifdef _WIN64
29976 static void thunk64_vkCmdSetCullModeEXT(void *args)
29977 {
29978     struct vkCmdSetCullModeEXT_params *params = args;
29979
29980     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
29981 }
29982 #endif /* _WIN64 */
29983
29984 static void thunk32_vkCmdSetCullModeEXT(void *args)
29985 {
29986     struct
29987     {
29988         PTR32 commandBuffer;
29989         VkCullModeFlags cullMode;
29990     } *params = args;
29991
29992     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCullModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->cullMode);
29993 }
29994
29995 #ifdef _WIN64
29996 static void thunk64_vkCmdSetDepthBias(void *args)
29997 {
29998     struct vkCmdSetDepthBias_params *params = args;
29999
30000     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);
30001 }
30002 #endif /* _WIN64 */
30003
30004 static void thunk32_vkCmdSetDepthBias(void *args)
30005 {
30006     struct
30007     {
30008         PTR32 commandBuffer;
30009         float depthBiasConstantFactor;
30010         float depthBiasClamp;
30011         float depthBiasSlopeFactor;
30012     } *params = args;
30013
30014     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBias(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
30015 }
30016
30017 #ifdef _WIN64
30018 static void thunk64_vkCmdSetDepthBiasEnable(void *args)
30019 {
30020     struct vkCmdSetDepthBiasEnable_params *params = args;
30021
30022     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
30023 }
30024 #endif /* _WIN64 */
30025
30026 static void thunk32_vkCmdSetDepthBiasEnable(void *args)
30027 {
30028     struct
30029     {
30030         PTR32 commandBuffer;
30031         VkBool32 depthBiasEnable;
30032     } *params = args;
30033
30034     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBiasEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBiasEnable);
30035 }
30036
30037 #ifdef _WIN64
30038 static void thunk64_vkCmdSetDepthBiasEnableEXT(void *args)
30039 {
30040     struct vkCmdSetDepthBiasEnableEXT_params *params = args;
30041
30042     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
30043 }
30044 #endif /* _WIN64 */
30045
30046 static void thunk32_vkCmdSetDepthBiasEnableEXT(void *args)
30047 {
30048     struct
30049     {
30050         PTR32 commandBuffer;
30051         VkBool32 depthBiasEnable;
30052     } *params = args;
30053
30054     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBiasEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBiasEnable);
30055 }
30056
30057 #ifdef _WIN64
30058 static void thunk64_vkCmdSetDepthBounds(void *args)
30059 {
30060     struct vkCmdSetDepthBounds_params *params = args;
30061
30062     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBounds(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->minDepthBounds, params->maxDepthBounds);
30063 }
30064 #endif /* _WIN64 */
30065
30066 static void thunk32_vkCmdSetDepthBounds(void *args)
30067 {
30068     struct
30069     {
30070         PTR32 commandBuffer;
30071         float minDepthBounds;
30072         float maxDepthBounds;
30073     } *params = args;
30074
30075     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBounds(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->minDepthBounds, params->maxDepthBounds);
30076 }
30077
30078 #ifdef _WIN64
30079 static void thunk64_vkCmdSetDepthBoundsTestEnable(void *args)
30080 {
30081     struct vkCmdSetDepthBoundsTestEnable_params *params = args;
30082
30083     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
30084 }
30085 #endif /* _WIN64 */
30086
30087 static void thunk32_vkCmdSetDepthBoundsTestEnable(void *args)
30088 {
30089     struct
30090     {
30091         PTR32 commandBuffer;
30092         VkBool32 depthBoundsTestEnable;
30093     } *params = args;
30094
30095     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBoundsTestEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBoundsTestEnable);
30096 }
30097
30098 #ifdef _WIN64
30099 static void thunk64_vkCmdSetDepthBoundsTestEnableEXT(void *args)
30100 {
30101     struct vkCmdSetDepthBoundsTestEnableEXT_params *params = args;
30102
30103     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
30104 }
30105 #endif /* _WIN64 */
30106
30107 static void thunk32_vkCmdSetDepthBoundsTestEnableEXT(void *args)
30108 {
30109     struct
30110     {
30111         PTR32 commandBuffer;
30112         VkBool32 depthBoundsTestEnable;
30113     } *params = args;
30114
30115     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBoundsTestEnable);
30116 }
30117
30118 #ifdef _WIN64
30119 static void thunk64_vkCmdSetDepthClampEnableEXT(void *args)
30120 {
30121     struct vkCmdSetDepthClampEnableEXT_params *params = args;
30122
30123     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClampEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClampEnable);
30124 }
30125 #endif /* _WIN64 */
30126
30127 static void thunk32_vkCmdSetDepthClampEnableEXT(void *args)
30128 {
30129     struct
30130     {
30131         PTR32 commandBuffer;
30132         VkBool32 depthClampEnable;
30133     } *params = args;
30134
30135     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthClampEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthClampEnable);
30136 }
30137
30138 #ifdef _WIN64
30139 static void thunk64_vkCmdSetDepthClipEnableEXT(void *args)
30140 {
30141     struct vkCmdSetDepthClipEnableEXT_params *params = args;
30142
30143     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClipEnable);
30144 }
30145 #endif /* _WIN64 */
30146
30147 static void thunk32_vkCmdSetDepthClipEnableEXT(void *args)
30148 {
30149     struct
30150     {
30151         PTR32 commandBuffer;
30152         VkBool32 depthClipEnable;
30153     } *params = args;
30154
30155     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthClipEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthClipEnable);
30156 }
30157
30158 #ifdef _WIN64
30159 static void thunk64_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
30160 {
30161     struct vkCmdSetDepthClipNegativeOneToOneEXT_params *params = args;
30162
30163     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipNegativeOneToOneEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->negativeOneToOne);
30164 }
30165 #endif /* _WIN64 */
30166
30167 static void thunk32_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
30168 {
30169     struct
30170     {
30171         PTR32 commandBuffer;
30172         VkBool32 negativeOneToOne;
30173     } *params = args;
30174
30175     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthClipNegativeOneToOneEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->negativeOneToOne);
30176 }
30177
30178 #ifdef _WIN64
30179 static void thunk64_vkCmdSetDepthCompareOp(void *args)
30180 {
30181     struct vkCmdSetDepthCompareOp_params *params = args;
30182
30183     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
30184 }
30185 #endif /* _WIN64 */
30186
30187 static void thunk32_vkCmdSetDepthCompareOp(void *args)
30188 {
30189     struct
30190     {
30191         PTR32 commandBuffer;
30192         VkCompareOp depthCompareOp;
30193     } *params = args;
30194
30195     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthCompareOp(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthCompareOp);
30196 }
30197
30198 #ifdef _WIN64
30199 static void thunk64_vkCmdSetDepthCompareOpEXT(void *args)
30200 {
30201     struct vkCmdSetDepthCompareOpEXT_params *params = args;
30202
30203     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
30204 }
30205 #endif /* _WIN64 */
30206
30207 static void thunk32_vkCmdSetDepthCompareOpEXT(void *args)
30208 {
30209     struct
30210     {
30211         PTR32 commandBuffer;
30212         VkCompareOp depthCompareOp;
30213     } *params = args;
30214
30215     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthCompareOpEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthCompareOp);
30216 }
30217
30218 #ifdef _WIN64
30219 static void thunk64_vkCmdSetDepthTestEnable(void *args)
30220 {
30221     struct vkCmdSetDepthTestEnable_params *params = args;
30222
30223     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
30224 }
30225 #endif /* _WIN64 */
30226
30227 static void thunk32_vkCmdSetDepthTestEnable(void *args)
30228 {
30229     struct
30230     {
30231         PTR32 commandBuffer;
30232         VkBool32 depthTestEnable;
30233     } *params = args;
30234
30235     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthTestEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthTestEnable);
30236 }
30237
30238 #ifdef _WIN64
30239 static void thunk64_vkCmdSetDepthTestEnableEXT(void *args)
30240 {
30241     struct vkCmdSetDepthTestEnableEXT_params *params = args;
30242
30243     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
30244 }
30245 #endif /* _WIN64 */
30246
30247 static void thunk32_vkCmdSetDepthTestEnableEXT(void *args)
30248 {
30249     struct
30250     {
30251         PTR32 commandBuffer;
30252         VkBool32 depthTestEnable;
30253     } *params = args;
30254
30255     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthTestEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthTestEnable);
30256 }
30257
30258 #ifdef _WIN64
30259 static void thunk64_vkCmdSetDepthWriteEnable(void *args)
30260 {
30261     struct vkCmdSetDepthWriteEnable_params *params = args;
30262
30263     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
30264 }
30265 #endif /* _WIN64 */
30266
30267 static void thunk32_vkCmdSetDepthWriteEnable(void *args)
30268 {
30269     struct
30270     {
30271         PTR32 commandBuffer;
30272         VkBool32 depthWriteEnable;
30273     } *params = args;
30274
30275     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthWriteEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthWriteEnable);
30276 }
30277
30278 #ifdef _WIN64
30279 static void thunk64_vkCmdSetDepthWriteEnableEXT(void *args)
30280 {
30281     struct vkCmdSetDepthWriteEnableEXT_params *params = args;
30282
30283     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
30284 }
30285 #endif /* _WIN64 */
30286
30287 static void thunk32_vkCmdSetDepthWriteEnableEXT(void *args)
30288 {
30289     struct
30290     {
30291         PTR32 commandBuffer;
30292         VkBool32 depthWriteEnable;
30293     } *params = args;
30294
30295     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthWriteEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthWriteEnable);
30296 }
30297
30298 #ifdef _WIN64
30299 static void thunk64_vkCmdSetDescriptorBufferOffsetsEXT(void *args)
30300 {
30301     struct vkCmdSetDescriptorBufferOffsetsEXT_params *params = args;
30302
30303     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDescriptorBufferOffsetsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->layout, params->firstSet, params->setCount, params->pBufferIndices, params->pOffsets);
30304 }
30305 #endif /* _WIN64 */
30306
30307 static void thunk32_vkCmdSetDescriptorBufferOffsetsEXT(void *args)
30308 {
30309     struct
30310     {
30311         PTR32 commandBuffer;
30312         VkPipelineBindPoint pipelineBindPoint;
30313         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
30314         uint32_t firstSet;
30315         uint32_t setCount;
30316         PTR32 pBufferIndices;
30317         PTR32 pOffsets;
30318     } *params = args;
30319
30320     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDescriptorBufferOffsetsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->layout, params->firstSet, params->setCount, (const uint32_t *)UlongToPtr(params->pBufferIndices), (const VkDeviceSize *)UlongToPtr(params->pOffsets));
30321 }
30322
30323 #ifdef _WIN64
30324 static void thunk64_vkCmdSetDeviceMask(void *args)
30325 {
30326     struct vkCmdSetDeviceMask_params *params = args;
30327
30328     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
30329 }
30330 #endif /* _WIN64 */
30331
30332 static void thunk32_vkCmdSetDeviceMask(void *args)
30333 {
30334     struct
30335     {
30336         PTR32 commandBuffer;
30337         uint32_t deviceMask;
30338     } *params = args;
30339
30340     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDeviceMask(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->deviceMask);
30341 }
30342
30343 #ifdef _WIN64
30344 static void thunk64_vkCmdSetDeviceMaskKHR(void *args)
30345 {
30346     struct vkCmdSetDeviceMaskKHR_params *params = args;
30347
30348     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMaskKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
30349 }
30350 #endif /* _WIN64 */
30351
30352 static void thunk32_vkCmdSetDeviceMaskKHR(void *args)
30353 {
30354     struct
30355     {
30356         PTR32 commandBuffer;
30357         uint32_t deviceMask;
30358     } *params = args;
30359
30360     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDeviceMaskKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->deviceMask);
30361 }
30362
30363 #ifdef _WIN64
30364 static void thunk64_vkCmdSetDiscardRectangleEXT(void *args)
30365 {
30366     struct vkCmdSetDiscardRectangleEXT_params *params = args;
30367
30368     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);
30369 }
30370 #endif /* _WIN64 */
30371
30372 static void thunk32_vkCmdSetDiscardRectangleEXT(void *args)
30373 {
30374     struct
30375     {
30376         PTR32 commandBuffer;
30377         uint32_t firstDiscardRectangle;
30378         uint32_t discardRectangleCount;
30379         PTR32 pDiscardRectangles;
30380     } *params = args;
30381
30382     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDiscardRectangleEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstDiscardRectangle, params->discardRectangleCount, (const VkRect2D *)UlongToPtr(params->pDiscardRectangles));
30383 }
30384
30385 #ifdef _WIN64
30386 static void thunk64_vkCmdSetDiscardRectangleEnableEXT(void *args)
30387 {
30388     struct vkCmdSetDiscardRectangleEnableEXT_params *params = args;
30389
30390     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDiscardRectangleEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->discardRectangleEnable);
30391 }
30392 #endif /* _WIN64 */
30393
30394 static void thunk32_vkCmdSetDiscardRectangleEnableEXT(void *args)
30395 {
30396     struct
30397     {
30398         PTR32 commandBuffer;
30399         VkBool32 discardRectangleEnable;
30400     } *params = args;
30401
30402     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDiscardRectangleEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->discardRectangleEnable);
30403 }
30404
30405 #ifdef _WIN64
30406 static void thunk64_vkCmdSetDiscardRectangleModeEXT(void *args)
30407 {
30408     struct vkCmdSetDiscardRectangleModeEXT_params *params = args;
30409
30410     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDiscardRectangleModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->discardRectangleMode);
30411 }
30412 #endif /* _WIN64 */
30413
30414 static void thunk32_vkCmdSetDiscardRectangleModeEXT(void *args)
30415 {
30416     struct
30417     {
30418         PTR32 commandBuffer;
30419         VkDiscardRectangleModeEXT discardRectangleMode;
30420     } *params = args;
30421
30422     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDiscardRectangleModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->discardRectangleMode);
30423 }
30424
30425 #ifdef _WIN64
30426 static void thunk64_vkCmdSetEvent(void *args)
30427 {
30428     struct vkCmdSetEvent_params *params = args;
30429
30430     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
30431 }
30432 #endif /* _WIN64 */
30433
30434 static void thunk32_vkCmdSetEvent(void *args)
30435 {
30436     struct
30437     {
30438         PTR32 commandBuffer;
30439         VkEvent DECLSPEC_ALIGN(8) event;
30440         VkPipelineStageFlags stageMask;
30441     } *params = args;
30442
30443     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetEvent(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, params->stageMask);
30444 }
30445
30446 #ifdef _WIN64
30447 static void thunk64_vkCmdSetEvent2(void *args)
30448 {
30449     struct vkCmdSetEvent2_params *params = args;
30450
30451     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->pDependencyInfo);
30452 }
30453 #endif /* _WIN64 */
30454
30455 static void thunk32_vkCmdSetEvent2(void *args)
30456 {
30457     struct
30458     {
30459         PTR32 commandBuffer;
30460         VkEvent DECLSPEC_ALIGN(8) event;
30461         PTR32 pDependencyInfo;
30462     } *params = args;
30463     VkDependencyInfo pDependencyInfo_host;
30464     struct conversion_context ctx;
30465
30466     init_conversion_context(&ctx);
30467     convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
30468     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetEvent2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, &pDependencyInfo_host);
30469     free_conversion_context(&ctx);
30470 }
30471
30472 #ifdef _WIN64
30473 static void thunk64_vkCmdSetEvent2KHR(void *args)
30474 {
30475     struct vkCmdSetEvent2KHR_params *params = args;
30476
30477     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->pDependencyInfo);
30478 }
30479 #endif /* _WIN64 */
30480
30481 static void thunk32_vkCmdSetEvent2KHR(void *args)
30482 {
30483     struct
30484     {
30485         PTR32 commandBuffer;
30486         VkEvent DECLSPEC_ALIGN(8) event;
30487         PTR32 pDependencyInfo;
30488     } *params = args;
30489     VkDependencyInfo pDependencyInfo_host;
30490     struct conversion_context ctx;
30491
30492     init_conversion_context(&ctx);
30493     convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
30494     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetEvent2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, &pDependencyInfo_host);
30495     free_conversion_context(&ctx);
30496 }
30497
30498 #ifdef _WIN64
30499 static void thunk64_vkCmdSetExclusiveScissorEnableNV(void *args)
30500 {
30501     struct vkCmdSetExclusiveScissorEnableNV_params *params = args;
30502
30503     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetExclusiveScissorEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstExclusiveScissor, params->exclusiveScissorCount, params->pExclusiveScissorEnables);
30504 }
30505 #endif /* _WIN64 */
30506
30507 static void thunk32_vkCmdSetExclusiveScissorEnableNV(void *args)
30508 {
30509     struct
30510     {
30511         PTR32 commandBuffer;
30512         uint32_t firstExclusiveScissor;
30513         uint32_t exclusiveScissorCount;
30514         PTR32 pExclusiveScissorEnables;
30515     } *params = args;
30516
30517     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetExclusiveScissorEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstExclusiveScissor, params->exclusiveScissorCount, (const VkBool32 *)UlongToPtr(params->pExclusiveScissorEnables));
30518 }
30519
30520 #ifdef _WIN64
30521 static void thunk64_vkCmdSetExclusiveScissorNV(void *args)
30522 {
30523     struct vkCmdSetExclusiveScissorNV_params *params = args;
30524
30525     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);
30526 }
30527 #endif /* _WIN64 */
30528
30529 static void thunk32_vkCmdSetExclusiveScissorNV(void *args)
30530 {
30531     struct
30532     {
30533         PTR32 commandBuffer;
30534         uint32_t firstExclusiveScissor;
30535         uint32_t exclusiveScissorCount;
30536         PTR32 pExclusiveScissors;
30537     } *params = args;
30538
30539     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetExclusiveScissorNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstExclusiveScissor, params->exclusiveScissorCount, (const VkRect2D *)UlongToPtr(params->pExclusiveScissors));
30540 }
30541
30542 #ifdef _WIN64
30543 static void thunk64_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
30544 {
30545     struct vkCmdSetExtraPrimitiveOverestimationSizeEXT_params *params = args;
30546
30547     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetExtraPrimitiveOverestimationSizeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->extraPrimitiveOverestimationSize);
30548 }
30549 #endif /* _WIN64 */
30550
30551 static void thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
30552 {
30553     struct
30554     {
30555         PTR32 commandBuffer;
30556         float extraPrimitiveOverestimationSize;
30557     } *params = args;
30558
30559     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetExtraPrimitiveOverestimationSizeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->extraPrimitiveOverestimationSize);
30560 }
30561
30562 #ifdef _WIN64
30563 static void thunk64_vkCmdSetFragmentShadingRateEnumNV(void *args)
30564 {
30565     struct vkCmdSetFragmentShadingRateEnumNV_params *params = args;
30566
30567     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateEnumNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRate, params->combinerOps);
30568 }
30569 #endif /* _WIN64 */
30570
30571 static void thunk32_vkCmdSetFragmentShadingRateEnumNV(void *args)
30572 {
30573     struct
30574     {
30575         PTR32 commandBuffer;
30576         VkFragmentShadingRateNV shadingRate;
30577         PTR32 combinerOps;
30578     } *params = args;
30579
30580     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetFragmentShadingRateEnumNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->shadingRate, (const VkFragmentShadingRateCombinerOpKHR *)UlongToPtr(params->combinerOps));
30581 }
30582
30583 #ifdef _WIN64
30584 static void thunk64_vkCmdSetFragmentShadingRateKHR(void *args)
30585 {
30586     struct vkCmdSetFragmentShadingRateKHR_params *params = args;
30587
30588     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pFragmentSize, params->combinerOps);
30589 }
30590 #endif /* _WIN64 */
30591
30592 static void thunk32_vkCmdSetFragmentShadingRateKHR(void *args)
30593 {
30594     struct
30595     {
30596         PTR32 commandBuffer;
30597         PTR32 pFragmentSize;
30598         PTR32 combinerOps;
30599     } *params = args;
30600
30601     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetFragmentShadingRateKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, (const VkExtent2D *)UlongToPtr(params->pFragmentSize), (const VkFragmentShadingRateCombinerOpKHR *)UlongToPtr(params->combinerOps));
30602 }
30603
30604 #ifdef _WIN64
30605 static void thunk64_vkCmdSetFrontFace(void *args)
30606 {
30607     struct vkCmdSetFrontFace_params *params = args;
30608
30609     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFace(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
30610 }
30611 #endif /* _WIN64 */
30612
30613 static void thunk32_vkCmdSetFrontFace(void *args)
30614 {
30615     struct
30616     {
30617         PTR32 commandBuffer;
30618         VkFrontFace frontFace;
30619     } *params = args;
30620
30621     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetFrontFace(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->frontFace);
30622 }
30623
30624 #ifdef _WIN64
30625 static void thunk64_vkCmdSetFrontFaceEXT(void *args)
30626 {
30627     struct vkCmdSetFrontFaceEXT_params *params = args;
30628
30629     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFaceEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
30630 }
30631 #endif /* _WIN64 */
30632
30633 static void thunk32_vkCmdSetFrontFaceEXT(void *args)
30634 {
30635     struct
30636     {
30637         PTR32 commandBuffer;
30638         VkFrontFace frontFace;
30639     } *params = args;
30640
30641     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetFrontFaceEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->frontFace);
30642 }
30643
30644 #ifdef _WIN64
30645 static void thunk64_vkCmdSetLineRasterizationModeEXT(void *args)
30646 {
30647     struct vkCmdSetLineRasterizationModeEXT_params *params = args;
30648
30649     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineRasterizationMode);
30650 }
30651 #endif /* _WIN64 */
30652
30653 static void thunk32_vkCmdSetLineRasterizationModeEXT(void *args)
30654 {
30655     struct
30656     {
30657         PTR32 commandBuffer;
30658         VkLineRasterizationModeEXT lineRasterizationMode;
30659     } *params = args;
30660
30661     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLineRasterizationModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->lineRasterizationMode);
30662 }
30663
30664 #ifdef _WIN64
30665 static void thunk64_vkCmdSetLineStippleEXT(void *args)
30666 {
30667     struct vkCmdSetLineStippleEXT_params *params = args;
30668
30669     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineStippleFactor, params->lineStipplePattern);
30670 }
30671 #endif /* _WIN64 */
30672
30673 static void thunk32_vkCmdSetLineStippleEXT(void *args)
30674 {
30675     struct
30676     {
30677         PTR32 commandBuffer;
30678         uint32_t lineStippleFactor;
30679         uint16_t lineStipplePattern;
30680     } *params = args;
30681
30682     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLineStippleEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->lineStippleFactor, params->lineStipplePattern);
30683 }
30684
30685 #ifdef _WIN64
30686 static void thunk64_vkCmdSetLineStippleEnableEXT(void *args)
30687 {
30688     struct vkCmdSetLineStippleEnableEXT_params *params = args;
30689
30690     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stippledLineEnable);
30691 }
30692 #endif /* _WIN64 */
30693
30694 static void thunk32_vkCmdSetLineStippleEnableEXT(void *args)
30695 {
30696     struct
30697     {
30698         PTR32 commandBuffer;
30699         VkBool32 stippledLineEnable;
30700     } *params = args;
30701
30702     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLineStippleEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stippledLineEnable);
30703 }
30704
30705 #ifdef _WIN64
30706 static void thunk64_vkCmdSetLineWidth(void *args)
30707 {
30708     struct vkCmdSetLineWidth_params *params = args;
30709
30710     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineWidth(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineWidth);
30711 }
30712 #endif /* _WIN64 */
30713
30714 static void thunk32_vkCmdSetLineWidth(void *args)
30715 {
30716     struct
30717     {
30718         PTR32 commandBuffer;
30719         float lineWidth;
30720     } *params = args;
30721
30722     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLineWidth(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->lineWidth);
30723 }
30724
30725 #ifdef _WIN64
30726 static void thunk64_vkCmdSetLogicOpEXT(void *args)
30727 {
30728     struct vkCmdSetLogicOpEXT_params *params = args;
30729
30730     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOp);
30731 }
30732 #endif /* _WIN64 */
30733
30734 static void thunk32_vkCmdSetLogicOpEXT(void *args)
30735 {
30736     struct
30737     {
30738         PTR32 commandBuffer;
30739         VkLogicOp logicOp;
30740     } *params = args;
30741
30742     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLogicOpEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->logicOp);
30743 }
30744
30745 #ifdef _WIN64
30746 static void thunk64_vkCmdSetLogicOpEnableEXT(void *args)
30747 {
30748     struct vkCmdSetLogicOpEnableEXT_params *params = args;
30749
30750     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOpEnable);
30751 }
30752 #endif /* _WIN64 */
30753
30754 static void thunk32_vkCmdSetLogicOpEnableEXT(void *args)
30755 {
30756     struct
30757     {
30758         PTR32 commandBuffer;
30759         VkBool32 logicOpEnable;
30760     } *params = args;
30761
30762     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLogicOpEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->logicOpEnable);
30763 }
30764
30765 #ifdef _WIN64
30766 static void thunk64_vkCmdSetPatchControlPointsEXT(void *args)
30767 {
30768     struct vkCmdSetPatchControlPointsEXT_params *params = args;
30769
30770     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPatchControlPointsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->patchControlPoints);
30771 }
30772 #endif /* _WIN64 */
30773
30774 static void thunk32_vkCmdSetPatchControlPointsEXT(void *args)
30775 {
30776     struct
30777     {
30778         PTR32 commandBuffer;
30779         uint32_t patchControlPoints;
30780     } *params = args;
30781
30782     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPatchControlPointsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->patchControlPoints);
30783 }
30784
30785 #ifdef _WIN64
30786 static NTSTATUS thunk64_vkCmdSetPerformanceMarkerINTEL(void *args)
30787 {
30788     struct vkCmdSetPerformanceMarkerINTEL_params *params = args;
30789
30790     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
30791
30792     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
30793     return STATUS_SUCCESS;
30794 }
30795 #endif /* _WIN64 */
30796
30797 static NTSTATUS thunk32_vkCmdSetPerformanceMarkerINTEL(void *args)
30798 {
30799     struct
30800     {
30801         PTR32 commandBuffer;
30802         PTR32 pMarkerInfo;
30803         VkResult result;
30804     } *params = args;
30805     VkPerformanceMarkerInfoINTEL pMarkerInfo_host;
30806
30807     TRACE("%#x, %#x\n", params->commandBuffer, params->pMarkerInfo);
30808
30809     convert_VkPerformanceMarkerInfoINTEL_win32_to_host((const VkPerformanceMarkerInfoINTEL32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
30810     params->result = wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPerformanceMarkerINTEL(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pMarkerInfo_host);
30811     return STATUS_SUCCESS;
30812 }
30813
30814 #ifdef _WIN64
30815 static NTSTATUS thunk64_vkCmdSetPerformanceOverrideINTEL(void *args)
30816 {
30817     struct vkCmdSetPerformanceOverrideINTEL_params *params = args;
30818
30819     TRACE("%p, %p\n", params->commandBuffer, params->pOverrideInfo);
30820
30821     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceOverrideINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pOverrideInfo);
30822     return STATUS_SUCCESS;
30823 }
30824 #endif /* _WIN64 */
30825
30826 static NTSTATUS thunk32_vkCmdSetPerformanceOverrideINTEL(void *args)
30827 {
30828     struct
30829     {
30830         PTR32 commandBuffer;
30831         PTR32 pOverrideInfo;
30832         VkResult result;
30833     } *params = args;
30834     VkPerformanceOverrideInfoINTEL pOverrideInfo_host;
30835
30836     TRACE("%#x, %#x\n", params->commandBuffer, params->pOverrideInfo);
30837
30838     convert_VkPerformanceOverrideInfoINTEL_win32_to_host((const VkPerformanceOverrideInfoINTEL32 *)UlongToPtr(params->pOverrideInfo), &pOverrideInfo_host);
30839     params->result = wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPerformanceOverrideINTEL(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pOverrideInfo_host);
30840     return STATUS_SUCCESS;
30841 }
30842
30843 #ifdef _WIN64
30844 static NTSTATUS thunk64_vkCmdSetPerformanceStreamMarkerINTEL(void *args)
30845 {
30846     struct vkCmdSetPerformanceStreamMarkerINTEL_params *params = args;
30847
30848     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
30849
30850     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceStreamMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
30851     return STATUS_SUCCESS;
30852 }
30853 #endif /* _WIN64 */
30854
30855 static NTSTATUS thunk32_vkCmdSetPerformanceStreamMarkerINTEL(void *args)
30856 {
30857     struct
30858     {
30859         PTR32 commandBuffer;
30860         PTR32 pMarkerInfo;
30861         VkResult result;
30862     } *params = args;
30863     VkPerformanceStreamMarkerInfoINTEL pMarkerInfo_host;
30864
30865     TRACE("%#x, %#x\n", params->commandBuffer, params->pMarkerInfo);
30866
30867     convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host((const VkPerformanceStreamMarkerInfoINTEL32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
30868     params->result = wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPerformanceStreamMarkerINTEL(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pMarkerInfo_host);
30869     return STATUS_SUCCESS;
30870 }
30871
30872 #ifdef _WIN64
30873 static void thunk64_vkCmdSetPolygonModeEXT(void *args)
30874 {
30875     struct vkCmdSetPolygonModeEXT_params *params = args;
30876
30877     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPolygonModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->polygonMode);
30878 }
30879 #endif /* _WIN64 */
30880
30881 static void thunk32_vkCmdSetPolygonModeEXT(void *args)
30882 {
30883     struct
30884     {
30885         PTR32 commandBuffer;
30886         VkPolygonMode polygonMode;
30887     } *params = args;
30888
30889     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPolygonModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->polygonMode);
30890 }
30891
30892 #ifdef _WIN64
30893 static void thunk64_vkCmdSetPrimitiveRestartEnable(void *args)
30894 {
30895     struct vkCmdSetPrimitiveRestartEnable_params *params = args;
30896
30897     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
30898 }
30899 #endif /* _WIN64 */
30900
30901 static void thunk32_vkCmdSetPrimitiveRestartEnable(void *args)
30902 {
30903     struct
30904     {
30905         PTR32 commandBuffer;
30906         VkBool32 primitiveRestartEnable;
30907     } *params = args;
30908
30909     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPrimitiveRestartEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->primitiveRestartEnable);
30910 }
30911
30912 #ifdef _WIN64
30913 static void thunk64_vkCmdSetPrimitiveRestartEnableEXT(void *args)
30914 {
30915     struct vkCmdSetPrimitiveRestartEnableEXT_params *params = args;
30916
30917     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
30918 }
30919 #endif /* _WIN64 */
30920
30921 static void thunk32_vkCmdSetPrimitiveRestartEnableEXT(void *args)
30922 {
30923     struct
30924     {
30925         PTR32 commandBuffer;
30926         VkBool32 primitiveRestartEnable;
30927     } *params = args;
30928
30929     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPrimitiveRestartEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->primitiveRestartEnable);
30930 }
30931
30932 #ifdef _WIN64
30933 static void thunk64_vkCmdSetPrimitiveTopology(void *args)
30934 {
30935     struct vkCmdSetPrimitiveTopology_params *params = args;
30936
30937     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopology(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
30938 }
30939 #endif /* _WIN64 */
30940
30941 static void thunk32_vkCmdSetPrimitiveTopology(void *args)
30942 {
30943     struct
30944     {
30945         PTR32 commandBuffer;
30946         VkPrimitiveTopology primitiveTopology;
30947     } *params = args;
30948
30949     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPrimitiveTopology(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->primitiveTopology);
30950 }
30951
30952 #ifdef _WIN64
30953 static void thunk64_vkCmdSetPrimitiveTopologyEXT(void *args)
30954 {
30955     struct vkCmdSetPrimitiveTopologyEXT_params *params = args;
30956
30957     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopologyEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
30958 }
30959 #endif /* _WIN64 */
30960
30961 static void thunk32_vkCmdSetPrimitiveTopologyEXT(void *args)
30962 {
30963     struct
30964     {
30965         PTR32 commandBuffer;
30966         VkPrimitiveTopology primitiveTopology;
30967     } *params = args;
30968
30969     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPrimitiveTopologyEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->primitiveTopology);
30970 }
30971
30972 #ifdef _WIN64
30973 static void thunk64_vkCmdSetProvokingVertexModeEXT(void *args)
30974 {
30975     struct vkCmdSetProvokingVertexModeEXT_params *params = args;
30976
30977     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetProvokingVertexModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->provokingVertexMode);
30978 }
30979 #endif /* _WIN64 */
30980
30981 static void thunk32_vkCmdSetProvokingVertexModeEXT(void *args)
30982 {
30983     struct
30984     {
30985         PTR32 commandBuffer;
30986         VkProvokingVertexModeEXT provokingVertexMode;
30987     } *params = args;
30988
30989     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetProvokingVertexModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->provokingVertexMode);
30990 }
30991
30992 #ifdef _WIN64
30993 static void thunk64_vkCmdSetRasterizationSamplesEXT(void *args)
30994 {
30995     struct vkCmdSetRasterizationSamplesEXT_params *params = args;
30996
30997     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationSamplesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationSamples);
30998 }
30999 #endif /* _WIN64 */
31000
31001 static void thunk32_vkCmdSetRasterizationSamplesEXT(void *args)
31002 {
31003     struct
31004     {
31005         PTR32 commandBuffer;
31006         VkSampleCountFlagBits rasterizationSamples;
31007     } *params = args;
31008
31009     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRasterizationSamplesEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->rasterizationSamples);
31010 }
31011
31012 #ifdef _WIN64
31013 static void thunk64_vkCmdSetRasterizationStreamEXT(void *args)
31014 {
31015     struct vkCmdSetRasterizationStreamEXT_params *params = args;
31016
31017     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationStreamEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationStream);
31018 }
31019 #endif /* _WIN64 */
31020
31021 static void thunk32_vkCmdSetRasterizationStreamEXT(void *args)
31022 {
31023     struct
31024     {
31025         PTR32 commandBuffer;
31026         uint32_t rasterizationStream;
31027     } *params = args;
31028
31029     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRasterizationStreamEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->rasterizationStream);
31030 }
31031
31032 #ifdef _WIN64
31033 static void thunk64_vkCmdSetRasterizerDiscardEnable(void *args)
31034 {
31035     struct vkCmdSetRasterizerDiscardEnable_params *params = args;
31036
31037     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
31038 }
31039 #endif /* _WIN64 */
31040
31041 static void thunk32_vkCmdSetRasterizerDiscardEnable(void *args)
31042 {
31043     struct
31044     {
31045         PTR32 commandBuffer;
31046         VkBool32 rasterizerDiscardEnable;
31047     } *params = args;
31048
31049     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRasterizerDiscardEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->rasterizerDiscardEnable);
31050 }
31051
31052 #ifdef _WIN64
31053 static void thunk64_vkCmdSetRasterizerDiscardEnableEXT(void *args)
31054 {
31055     struct vkCmdSetRasterizerDiscardEnableEXT_params *params = args;
31056
31057     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
31058 }
31059 #endif /* _WIN64 */
31060
31061 static void thunk32_vkCmdSetRasterizerDiscardEnableEXT(void *args)
31062 {
31063     struct
31064     {
31065         PTR32 commandBuffer;
31066         VkBool32 rasterizerDiscardEnable;
31067     } *params = args;
31068
31069     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRasterizerDiscardEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->rasterizerDiscardEnable);
31070 }
31071
31072 #ifdef _WIN64
31073 static void thunk64_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
31074 {
31075     struct vkCmdSetRayTracingPipelineStackSizeKHR_params *params = args;
31076
31077     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRayTracingPipelineStackSizeKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStackSize);
31078 }
31079 #endif /* _WIN64 */
31080
31081 static void thunk32_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
31082 {
31083     struct
31084     {
31085         PTR32 commandBuffer;
31086         uint32_t pipelineStackSize;
31087     } *params = args;
31088
31089     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRayTracingPipelineStackSizeKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineStackSize);
31090 }
31091
31092 #ifdef _WIN64
31093 static void thunk64_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
31094 {
31095     struct vkCmdSetRepresentativeFragmentTestEnableNV_params *params = args;
31096
31097     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRepresentativeFragmentTestEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->representativeFragmentTestEnable);
31098 }
31099 #endif /* _WIN64 */
31100
31101 static void thunk32_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
31102 {
31103     struct
31104     {
31105         PTR32 commandBuffer;
31106         VkBool32 representativeFragmentTestEnable;
31107     } *params = args;
31108
31109     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRepresentativeFragmentTestEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->representativeFragmentTestEnable);
31110 }
31111
31112 #ifdef _WIN64
31113 static void thunk64_vkCmdSetSampleLocationsEXT(void *args)
31114 {
31115     struct vkCmdSetSampleLocationsEXT_params *params = args;
31116
31117     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSampleLocationsInfo);
31118 }
31119 #endif /* _WIN64 */
31120
31121 static void thunk32_vkCmdSetSampleLocationsEXT(void *args)
31122 {
31123     struct
31124     {
31125         PTR32 commandBuffer;
31126         PTR32 pSampleLocationsInfo;
31127     } *params = args;
31128     VkSampleLocationsInfoEXT pSampleLocationsInfo_host;
31129
31130     convert_VkSampleLocationsInfoEXT_win32_to_host((const VkSampleLocationsInfoEXT32 *)UlongToPtr(params->pSampleLocationsInfo), &pSampleLocationsInfo_host);
31131     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetSampleLocationsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pSampleLocationsInfo_host);
31132 }
31133
31134 #ifdef _WIN64
31135 static void thunk64_vkCmdSetSampleLocationsEnableEXT(void *args)
31136 {
31137     struct vkCmdSetSampleLocationsEnableEXT_params *params = args;
31138
31139     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->sampleLocationsEnable);
31140 }
31141 #endif /* _WIN64 */
31142
31143 static void thunk32_vkCmdSetSampleLocationsEnableEXT(void *args)
31144 {
31145     struct
31146     {
31147         PTR32 commandBuffer;
31148         VkBool32 sampleLocationsEnable;
31149     } *params = args;
31150
31151     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetSampleLocationsEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->sampleLocationsEnable);
31152 }
31153
31154 #ifdef _WIN64
31155 static void thunk64_vkCmdSetSampleMaskEXT(void *args)
31156 {
31157     struct vkCmdSetSampleMaskEXT_params *params = args;
31158
31159     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->samples, params->pSampleMask);
31160 }
31161 #endif /* _WIN64 */
31162
31163 static void thunk32_vkCmdSetSampleMaskEXT(void *args)
31164 {
31165     struct
31166     {
31167         PTR32 commandBuffer;
31168         VkSampleCountFlagBits samples;
31169         PTR32 pSampleMask;
31170     } *params = args;
31171
31172     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetSampleMaskEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->samples, (const VkSampleMask *)UlongToPtr(params->pSampleMask));
31173 }
31174
31175 #ifdef _WIN64
31176 static void thunk64_vkCmdSetScissor(void *args)
31177 {
31178     struct vkCmdSetScissor_params *params = args;
31179
31180     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);
31181 }
31182 #endif /* _WIN64 */
31183
31184 static void thunk32_vkCmdSetScissor(void *args)
31185 {
31186     struct
31187     {
31188         PTR32 commandBuffer;
31189         uint32_t firstScissor;
31190         uint32_t scissorCount;
31191         PTR32 pScissors;
31192     } *params = args;
31193
31194     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetScissor(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstScissor, params->scissorCount, (const VkRect2D *)UlongToPtr(params->pScissors));
31195 }
31196
31197 #ifdef _WIN64
31198 static void thunk64_vkCmdSetScissorWithCount(void *args)
31199 {
31200     struct vkCmdSetScissorWithCount_params *params = args;
31201
31202     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
31203 }
31204 #endif /* _WIN64 */
31205
31206 static void thunk32_vkCmdSetScissorWithCount(void *args)
31207 {
31208     struct
31209     {
31210         PTR32 commandBuffer;
31211         uint32_t scissorCount;
31212         PTR32 pScissors;
31213     } *params = args;
31214
31215     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetScissorWithCount(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->scissorCount, (const VkRect2D *)UlongToPtr(params->pScissors));
31216 }
31217
31218 #ifdef _WIN64
31219 static void thunk64_vkCmdSetScissorWithCountEXT(void *args)
31220 {
31221     struct vkCmdSetScissorWithCountEXT_params *params = args;
31222
31223     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
31224 }
31225 #endif /* _WIN64 */
31226
31227 static void thunk32_vkCmdSetScissorWithCountEXT(void *args)
31228 {
31229     struct
31230     {
31231         PTR32 commandBuffer;
31232         uint32_t scissorCount;
31233         PTR32 pScissors;
31234     } *params = args;
31235
31236     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetScissorWithCountEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->scissorCount, (const VkRect2D *)UlongToPtr(params->pScissors));
31237 }
31238
31239 #ifdef _WIN64
31240 static void thunk64_vkCmdSetShadingRateImageEnableNV(void *args)
31241 {
31242     struct vkCmdSetShadingRateImageEnableNV_params *params = args;
31243
31244     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetShadingRateImageEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRateImageEnable);
31245 }
31246 #endif /* _WIN64 */
31247
31248 static void thunk32_vkCmdSetShadingRateImageEnableNV(void *args)
31249 {
31250     struct
31251     {
31252         PTR32 commandBuffer;
31253         VkBool32 shadingRateImageEnable;
31254     } *params = args;
31255
31256     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetShadingRateImageEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->shadingRateImageEnable);
31257 }
31258
31259 #ifdef _WIN64
31260 static void thunk64_vkCmdSetStencilCompareMask(void *args)
31261 {
31262     struct vkCmdSetStencilCompareMask_params *params = args;
31263
31264     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilCompareMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->compareMask);
31265 }
31266 #endif /* _WIN64 */
31267
31268 static void thunk32_vkCmdSetStencilCompareMask(void *args)
31269 {
31270     struct
31271     {
31272         PTR32 commandBuffer;
31273         VkStencilFaceFlags faceMask;
31274         uint32_t compareMask;
31275     } *params = args;
31276
31277     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilCompareMask(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->compareMask);
31278 }
31279
31280 #ifdef _WIN64
31281 static void thunk64_vkCmdSetStencilOp(void *args)
31282 {
31283     struct vkCmdSetStencilOp_params *params = args;
31284
31285     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);
31286 }
31287 #endif /* _WIN64 */
31288
31289 static void thunk32_vkCmdSetStencilOp(void *args)
31290 {
31291     struct
31292     {
31293         PTR32 commandBuffer;
31294         VkStencilFaceFlags faceMask;
31295         VkStencilOp failOp;
31296         VkStencilOp passOp;
31297         VkStencilOp depthFailOp;
31298         VkCompareOp compareOp;
31299     } *params = args;
31300
31301     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilOp(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
31302 }
31303
31304 #ifdef _WIN64
31305 static void thunk64_vkCmdSetStencilOpEXT(void *args)
31306 {
31307     struct vkCmdSetStencilOpEXT_params *params = args;
31308
31309     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);
31310 }
31311 #endif /* _WIN64 */
31312
31313 static void thunk32_vkCmdSetStencilOpEXT(void *args)
31314 {
31315     struct
31316     {
31317         PTR32 commandBuffer;
31318         VkStencilFaceFlags faceMask;
31319         VkStencilOp failOp;
31320         VkStencilOp passOp;
31321         VkStencilOp depthFailOp;
31322         VkCompareOp compareOp;
31323     } *params = args;
31324
31325     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilOpEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
31326 }
31327
31328 #ifdef _WIN64
31329 static void thunk64_vkCmdSetStencilReference(void *args)
31330 {
31331     struct vkCmdSetStencilReference_params *params = args;
31332
31333     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilReference(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->reference);
31334 }
31335 #endif /* _WIN64 */
31336
31337 static void thunk32_vkCmdSetStencilReference(void *args)
31338 {
31339     struct
31340     {
31341         PTR32 commandBuffer;
31342         VkStencilFaceFlags faceMask;
31343         uint32_t reference;
31344     } *params = args;
31345
31346     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilReference(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->reference);
31347 }
31348
31349 #ifdef _WIN64
31350 static void thunk64_vkCmdSetStencilTestEnable(void *args)
31351 {
31352     struct vkCmdSetStencilTestEnable_params *params = args;
31353
31354     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
31355 }
31356 #endif /* _WIN64 */
31357
31358 static void thunk32_vkCmdSetStencilTestEnable(void *args)
31359 {
31360     struct
31361     {
31362         PTR32 commandBuffer;
31363         VkBool32 stencilTestEnable;
31364     } *params = args;
31365
31366     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilTestEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stencilTestEnable);
31367 }
31368
31369 #ifdef _WIN64
31370 static void thunk64_vkCmdSetStencilTestEnableEXT(void *args)
31371 {
31372     struct vkCmdSetStencilTestEnableEXT_params *params = args;
31373
31374     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
31375 }
31376 #endif /* _WIN64 */
31377
31378 static void thunk32_vkCmdSetStencilTestEnableEXT(void *args)
31379 {
31380     struct
31381     {
31382         PTR32 commandBuffer;
31383         VkBool32 stencilTestEnable;
31384     } *params = args;
31385
31386     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilTestEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stencilTestEnable);
31387 }
31388
31389 #ifdef _WIN64
31390 static void thunk64_vkCmdSetStencilWriteMask(void *args)
31391 {
31392     struct vkCmdSetStencilWriteMask_params *params = args;
31393
31394     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilWriteMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->writeMask);
31395 }
31396 #endif /* _WIN64 */
31397
31398 static void thunk32_vkCmdSetStencilWriteMask(void *args)
31399 {
31400     struct
31401     {
31402         PTR32 commandBuffer;
31403         VkStencilFaceFlags faceMask;
31404         uint32_t writeMask;
31405     } *params = args;
31406
31407     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilWriteMask(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->writeMask);
31408 }
31409
31410 #ifdef _WIN64
31411 static void thunk64_vkCmdSetTessellationDomainOriginEXT(void *args)
31412 {
31413     struct vkCmdSetTessellationDomainOriginEXT_params *params = args;
31414
31415     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetTessellationDomainOriginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->domainOrigin);
31416 }
31417 #endif /* _WIN64 */
31418
31419 static void thunk32_vkCmdSetTessellationDomainOriginEXT(void *args)
31420 {
31421     struct
31422     {
31423         PTR32 commandBuffer;
31424         VkTessellationDomainOrigin domainOrigin;
31425     } *params = args;
31426
31427     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetTessellationDomainOriginEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->domainOrigin);
31428 }
31429
31430 #ifdef _WIN64
31431 static void thunk64_vkCmdSetVertexInputEXT(void *args)
31432 {
31433     struct vkCmdSetVertexInputEXT_params *params = args;
31434
31435     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);
31436 }
31437 #endif /* _WIN64 */
31438
31439 static void thunk32_vkCmdSetVertexInputEXT(void *args)
31440 {
31441     struct
31442     {
31443         PTR32 commandBuffer;
31444         uint32_t vertexBindingDescriptionCount;
31445         PTR32 pVertexBindingDescriptions;
31446         uint32_t vertexAttributeDescriptionCount;
31447         PTR32 pVertexAttributeDescriptions;
31448     } *params = args;
31449     const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions_host;
31450     const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions_host;
31451     struct conversion_context ctx;
31452
31453     init_conversion_context(&ctx);
31454     pVertexBindingDescriptions_host = convert_VkVertexInputBindingDescription2EXT_array_win32_to_host(&ctx, (const VkVertexInputBindingDescription2EXT32 *)UlongToPtr(params->pVertexBindingDescriptions), params->vertexBindingDescriptionCount);
31455     pVertexAttributeDescriptions_host = convert_VkVertexInputAttributeDescription2EXT_array_win32_to_host(&ctx, (const VkVertexInputAttributeDescription2EXT32 *)UlongToPtr(params->pVertexAttributeDescriptions), params->vertexAttributeDescriptionCount);
31456     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetVertexInputEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->vertexBindingDescriptionCount, pVertexBindingDescriptions_host, params->vertexAttributeDescriptionCount, pVertexAttributeDescriptions_host);
31457     free_conversion_context(&ctx);
31458 }
31459
31460 #ifdef _WIN64
31461 static void thunk64_vkCmdSetViewport(void *args)
31462 {
31463     struct vkCmdSetViewport_params *params = args;
31464
31465     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);
31466 }
31467 #endif /* _WIN64 */
31468
31469 static void thunk32_vkCmdSetViewport(void *args)
31470 {
31471     struct
31472     {
31473         PTR32 commandBuffer;
31474         uint32_t firstViewport;
31475         uint32_t viewportCount;
31476         PTR32 pViewports;
31477     } *params = args;
31478
31479     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewport(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstViewport, params->viewportCount, (const VkViewport *)UlongToPtr(params->pViewports));
31480 }
31481
31482 #ifdef _WIN64
31483 static void thunk64_vkCmdSetViewportShadingRatePaletteNV(void *args)
31484 {
31485     struct vkCmdSetViewportShadingRatePaletteNV_params *params = args;
31486
31487     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);
31488 }
31489 #endif /* _WIN64 */
31490
31491 static void thunk32_vkCmdSetViewportShadingRatePaletteNV(void *args)
31492 {
31493     struct
31494     {
31495         PTR32 commandBuffer;
31496         uint32_t firstViewport;
31497         uint32_t viewportCount;
31498         PTR32 pShadingRatePalettes;
31499     } *params = args;
31500     const VkShadingRatePaletteNV *pShadingRatePalettes_host;
31501     struct conversion_context ctx;
31502
31503     init_conversion_context(&ctx);
31504     pShadingRatePalettes_host = convert_VkShadingRatePaletteNV_array_win32_to_host(&ctx, (const VkShadingRatePaletteNV32 *)UlongToPtr(params->pShadingRatePalettes), params->viewportCount);
31505     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportShadingRatePaletteNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstViewport, params->viewportCount, pShadingRatePalettes_host);
31506     free_conversion_context(&ctx);
31507 }
31508
31509 #ifdef _WIN64
31510 static void thunk64_vkCmdSetViewportSwizzleNV(void *args)
31511 {
31512     struct vkCmdSetViewportSwizzleNV_params *params = args;
31513
31514     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);
31515 }
31516 #endif /* _WIN64 */
31517
31518 static void thunk32_vkCmdSetViewportSwizzleNV(void *args)
31519 {
31520     struct
31521     {
31522         PTR32 commandBuffer;
31523         uint32_t firstViewport;
31524         uint32_t viewportCount;
31525         PTR32 pViewportSwizzles;
31526     } *params = args;
31527
31528     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportSwizzleNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstViewport, params->viewportCount, (const VkViewportSwizzleNV *)UlongToPtr(params->pViewportSwizzles));
31529 }
31530
31531 #ifdef _WIN64
31532 static void thunk64_vkCmdSetViewportWScalingEnableNV(void *args)
31533 {
31534     struct vkCmdSetViewportWScalingEnableNV_params *params = args;
31535
31536     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWScalingEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportWScalingEnable);
31537 }
31538 #endif /* _WIN64 */
31539
31540 static void thunk32_vkCmdSetViewportWScalingEnableNV(void *args)
31541 {
31542     struct
31543     {
31544         PTR32 commandBuffer;
31545         VkBool32 viewportWScalingEnable;
31546     } *params = args;
31547
31548     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportWScalingEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->viewportWScalingEnable);
31549 }
31550
31551 #ifdef _WIN64
31552 static void thunk64_vkCmdSetViewportWScalingNV(void *args)
31553 {
31554     struct vkCmdSetViewportWScalingNV_params *params = args;
31555
31556     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);
31557 }
31558 #endif /* _WIN64 */
31559
31560 static void thunk32_vkCmdSetViewportWScalingNV(void *args)
31561 {
31562     struct
31563     {
31564         PTR32 commandBuffer;
31565         uint32_t firstViewport;
31566         uint32_t viewportCount;
31567         PTR32 pViewportWScalings;
31568     } *params = args;
31569
31570     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportWScalingNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstViewport, params->viewportCount, (const VkViewportWScalingNV *)UlongToPtr(params->pViewportWScalings));
31571 }
31572
31573 #ifdef _WIN64
31574 static void thunk64_vkCmdSetViewportWithCount(void *args)
31575 {
31576     struct vkCmdSetViewportWithCount_params *params = args;
31577
31578     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
31579 }
31580 #endif /* _WIN64 */
31581
31582 static void thunk32_vkCmdSetViewportWithCount(void *args)
31583 {
31584     struct
31585     {
31586         PTR32 commandBuffer;
31587         uint32_t viewportCount;
31588         PTR32 pViewports;
31589     } *params = args;
31590
31591     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportWithCount(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->viewportCount, (const VkViewport *)UlongToPtr(params->pViewports));
31592 }
31593
31594 #ifdef _WIN64
31595 static void thunk64_vkCmdSetViewportWithCountEXT(void *args)
31596 {
31597     struct vkCmdSetViewportWithCountEXT_params *params = args;
31598
31599     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
31600 }
31601 #endif /* _WIN64 */
31602
31603 static void thunk32_vkCmdSetViewportWithCountEXT(void *args)
31604 {
31605     struct
31606     {
31607         PTR32 commandBuffer;
31608         uint32_t viewportCount;
31609         PTR32 pViewports;
31610     } *params = args;
31611
31612     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportWithCountEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->viewportCount, (const VkViewport *)UlongToPtr(params->pViewports));
31613 }
31614
31615 #ifdef _WIN64
31616 static void thunk64_vkCmdSubpassShadingHUAWEI(void *args)
31617 {
31618     struct vkCmdSubpassShadingHUAWEI_params *params = args;
31619
31620     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSubpassShadingHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
31621 }
31622 #endif /* _WIN64 */
31623
31624 static void thunk32_vkCmdSubpassShadingHUAWEI(void *args)
31625 {
31626     struct
31627     {
31628         PTR32 commandBuffer;
31629     } *params = args;
31630
31631     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSubpassShadingHUAWEI(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
31632 }
31633
31634 #ifdef _WIN64
31635 static void thunk64_vkCmdTraceRaysIndirect2KHR(void *args)
31636 {
31637     struct vkCmdTraceRaysIndirect2KHR_params *params = args;
31638
31639     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysIndirect2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indirectDeviceAddress);
31640 }
31641 #endif /* _WIN64 */
31642
31643 static void thunk32_vkCmdTraceRaysIndirect2KHR(void *args)
31644 {
31645     struct
31646     {
31647         PTR32 commandBuffer;
31648         VkDeviceAddress DECLSPEC_ALIGN(8) indirectDeviceAddress;
31649     } *params = args;
31650
31651     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdTraceRaysIndirect2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->indirectDeviceAddress);
31652 }
31653
31654 #ifdef _WIN64
31655 static void thunk64_vkCmdTraceRaysIndirectKHR(void *args)
31656 {
31657     struct vkCmdTraceRaysIndirectKHR_params *params = args;
31658
31659     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);
31660 }
31661 #endif /* _WIN64 */
31662
31663 static void thunk32_vkCmdTraceRaysIndirectKHR(void *args)
31664 {
31665     struct
31666     {
31667         PTR32 commandBuffer;
31668         PTR32 pRaygenShaderBindingTable;
31669         PTR32 pMissShaderBindingTable;
31670         PTR32 pHitShaderBindingTable;
31671         PTR32 pCallableShaderBindingTable;
31672         VkDeviceAddress DECLSPEC_ALIGN(8) indirectDeviceAddress;
31673     } *params = args;
31674     VkStridedDeviceAddressRegionKHR pRaygenShaderBindingTable_host;
31675     VkStridedDeviceAddressRegionKHR pMissShaderBindingTable_host;
31676     VkStridedDeviceAddressRegionKHR pHitShaderBindingTable_host;
31677     VkStridedDeviceAddressRegionKHR pCallableShaderBindingTable_host;
31678
31679     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pRaygenShaderBindingTable), &pRaygenShaderBindingTable_host);
31680     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pMissShaderBindingTable), &pMissShaderBindingTable_host);
31681     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pHitShaderBindingTable), &pHitShaderBindingTable_host);
31682     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pCallableShaderBindingTable), &pCallableShaderBindingTable_host);
31683     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdTraceRaysIndirectKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRaygenShaderBindingTable_host, &pMissShaderBindingTable_host, &pHitShaderBindingTable_host, &pCallableShaderBindingTable_host, params->indirectDeviceAddress);
31684 }
31685
31686 #ifdef _WIN64
31687 static void thunk64_vkCmdTraceRaysKHR(void *args)
31688 {
31689     struct vkCmdTraceRaysKHR_params *params = args;
31690
31691     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);
31692 }
31693 #endif /* _WIN64 */
31694
31695 static void thunk32_vkCmdTraceRaysKHR(void *args)
31696 {
31697     struct
31698     {
31699         PTR32 commandBuffer;
31700         PTR32 pRaygenShaderBindingTable;
31701         PTR32 pMissShaderBindingTable;
31702         PTR32 pHitShaderBindingTable;
31703         PTR32 pCallableShaderBindingTable;
31704         uint32_t width;
31705         uint32_t height;
31706         uint32_t depth;
31707     } *params = args;
31708     VkStridedDeviceAddressRegionKHR pRaygenShaderBindingTable_host;
31709     VkStridedDeviceAddressRegionKHR pMissShaderBindingTable_host;
31710     VkStridedDeviceAddressRegionKHR pHitShaderBindingTable_host;
31711     VkStridedDeviceAddressRegionKHR pCallableShaderBindingTable_host;
31712
31713     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pRaygenShaderBindingTable), &pRaygenShaderBindingTable_host);
31714     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pMissShaderBindingTable), &pMissShaderBindingTable_host);
31715     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pHitShaderBindingTable), &pHitShaderBindingTable_host);
31716     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pCallableShaderBindingTable), &pCallableShaderBindingTable_host);
31717     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdTraceRaysKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRaygenShaderBindingTable_host, &pMissShaderBindingTable_host, &pHitShaderBindingTable_host, &pCallableShaderBindingTable_host, params->width, params->height, params->depth);
31718 }
31719
31720 #ifdef _WIN64
31721 static void thunk64_vkCmdTraceRaysNV(void *args)
31722 {
31723     struct vkCmdTraceRaysNV_params *params = args;
31724
31725     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);
31726 }
31727 #endif /* _WIN64 */
31728
31729 static void thunk32_vkCmdTraceRaysNV(void *args)
31730 {
31731     struct
31732     {
31733         PTR32 commandBuffer;
31734         VkBuffer DECLSPEC_ALIGN(8) raygenShaderBindingTableBuffer;
31735         VkDeviceSize DECLSPEC_ALIGN(8) raygenShaderBindingOffset;
31736         VkBuffer DECLSPEC_ALIGN(8) missShaderBindingTableBuffer;
31737         VkDeviceSize DECLSPEC_ALIGN(8) missShaderBindingOffset;
31738         VkDeviceSize DECLSPEC_ALIGN(8) missShaderBindingStride;
31739         VkBuffer DECLSPEC_ALIGN(8) hitShaderBindingTableBuffer;
31740         VkDeviceSize DECLSPEC_ALIGN(8) hitShaderBindingOffset;
31741         VkDeviceSize DECLSPEC_ALIGN(8) hitShaderBindingStride;
31742         VkBuffer DECLSPEC_ALIGN(8) callableShaderBindingTableBuffer;
31743         VkDeviceSize DECLSPEC_ALIGN(8) callableShaderBindingOffset;
31744         VkDeviceSize DECLSPEC_ALIGN(8) callableShaderBindingStride;
31745         uint32_t width;
31746         uint32_t height;
31747         uint32_t depth;
31748     } *params = args;
31749
31750     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdTraceRaysNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(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);
31751 }
31752
31753 #ifdef _WIN64
31754 static void thunk64_vkCmdUpdateBuffer(void *args)
31755 {
31756     struct vkCmdUpdateBuffer_params *params = args;
31757
31758     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);
31759 }
31760 #endif /* _WIN64 */
31761
31762 static void thunk32_vkCmdUpdateBuffer(void *args)
31763 {
31764     struct
31765     {
31766         PTR32 commandBuffer;
31767         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
31768         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
31769         VkDeviceSize DECLSPEC_ALIGN(8) dataSize;
31770         PTR32 pData;
31771     } *params = args;
31772
31773     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdUpdateBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->dstBuffer, params->dstOffset, params->dataSize, (const void *)UlongToPtr(params->pData));
31774 }
31775
31776 #ifdef _WIN64
31777 static void thunk64_vkCmdWaitEvents(void *args)
31778 {
31779     struct vkCmdWaitEvents_params *params = args;
31780
31781     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);
31782 }
31783 #endif /* _WIN64 */
31784
31785 static void thunk32_vkCmdWaitEvents(void *args)
31786 {
31787     struct
31788     {
31789         PTR32 commandBuffer;
31790         uint32_t eventCount;
31791         PTR32 pEvents;
31792         VkPipelineStageFlags srcStageMask;
31793         VkPipelineStageFlags dstStageMask;
31794         uint32_t memoryBarrierCount;
31795         PTR32 pMemoryBarriers;
31796         uint32_t bufferMemoryBarrierCount;
31797         PTR32 pBufferMemoryBarriers;
31798         uint32_t imageMemoryBarrierCount;
31799         PTR32 pImageMemoryBarriers;
31800     } *params = args;
31801     const VkMemoryBarrier *pMemoryBarriers_host;
31802     const VkBufferMemoryBarrier *pBufferMemoryBarriers_host;
31803     const VkImageMemoryBarrier *pImageMemoryBarriers_host;
31804     struct conversion_context ctx;
31805
31806     init_conversion_context(&ctx);
31807     pMemoryBarriers_host = convert_VkMemoryBarrier_array_win32_to_host(&ctx, (const VkMemoryBarrier32 *)UlongToPtr(params->pMemoryBarriers), params->memoryBarrierCount);
31808     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win32_to_host(&ctx, (const VkBufferMemoryBarrier32 *)UlongToPtr(params->pBufferMemoryBarriers), params->bufferMemoryBarrierCount);
31809     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win32_to_host(&ctx, (const VkImageMemoryBarrier32 *)UlongToPtr(params->pImageMemoryBarriers), params->imageMemoryBarrierCount);
31810     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWaitEvents(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->eventCount, (const VkEvent *)UlongToPtr(params->pEvents), params->srcStageMask, params->dstStageMask, params->memoryBarrierCount, pMemoryBarriers_host, params->bufferMemoryBarrierCount, pBufferMemoryBarriers_host, params->imageMemoryBarrierCount, pImageMemoryBarriers_host);
31811     free_conversion_context(&ctx);
31812 }
31813
31814 #ifdef _WIN64
31815 static void thunk64_vkCmdWaitEvents2(void *args)
31816 {
31817     struct vkCmdWaitEvents2_params *params = args;
31818
31819     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);
31820 }
31821 #endif /* _WIN64 */
31822
31823 static void thunk32_vkCmdWaitEvents2(void *args)
31824 {
31825     struct
31826     {
31827         PTR32 commandBuffer;
31828         uint32_t eventCount;
31829         PTR32 pEvents;
31830         PTR32 pDependencyInfos;
31831     } *params = args;
31832     const VkDependencyInfo *pDependencyInfos_host;
31833     struct conversion_context ctx;
31834
31835     init_conversion_context(&ctx);
31836     pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfos), params->eventCount);
31837     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWaitEvents2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->eventCount, (const VkEvent *)UlongToPtr(params->pEvents), pDependencyInfos_host);
31838     free_conversion_context(&ctx);
31839 }
31840
31841 #ifdef _WIN64
31842 static void thunk64_vkCmdWaitEvents2KHR(void *args)
31843 {
31844     struct vkCmdWaitEvents2KHR_params *params = args;
31845
31846     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);
31847 }
31848 #endif /* _WIN64 */
31849
31850 static void thunk32_vkCmdWaitEvents2KHR(void *args)
31851 {
31852     struct
31853     {
31854         PTR32 commandBuffer;
31855         uint32_t eventCount;
31856         PTR32 pEvents;
31857         PTR32 pDependencyInfos;
31858     } *params = args;
31859     const VkDependencyInfo *pDependencyInfos_host;
31860     struct conversion_context ctx;
31861
31862     init_conversion_context(&ctx);
31863     pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfos), params->eventCount);
31864     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWaitEvents2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->eventCount, (const VkEvent *)UlongToPtr(params->pEvents), pDependencyInfos_host);
31865     free_conversion_context(&ctx);
31866 }
31867
31868 #ifdef _WIN64
31869 static void thunk64_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args)
31870 {
31871     struct vkCmdWriteAccelerationStructuresPropertiesKHR_params *params = args;
31872
31873     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);
31874 }
31875 #endif /* _WIN64 */
31876
31877 static void thunk32_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args)
31878 {
31879     struct
31880     {
31881         PTR32 commandBuffer;
31882         uint32_t accelerationStructureCount;
31883         PTR32 pAccelerationStructures;
31884         VkQueryType queryType;
31885         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
31886         uint32_t firstQuery;
31887     } *params = args;
31888
31889     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->accelerationStructureCount, (const VkAccelerationStructureKHR *)UlongToPtr(params->pAccelerationStructures), params->queryType, params->queryPool, params->firstQuery);
31890 }
31891
31892 #ifdef _WIN64
31893 static void thunk64_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
31894 {
31895     struct vkCmdWriteAccelerationStructuresPropertiesNV_params *params = args;
31896
31897     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);
31898 }
31899 #endif /* _WIN64 */
31900
31901 static void thunk32_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
31902 {
31903     struct
31904     {
31905         PTR32 commandBuffer;
31906         uint32_t accelerationStructureCount;
31907         PTR32 pAccelerationStructures;
31908         VkQueryType queryType;
31909         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
31910         uint32_t firstQuery;
31911     } *params = args;
31912
31913     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->accelerationStructureCount, (const VkAccelerationStructureNV *)UlongToPtr(params->pAccelerationStructures), params->queryType, params->queryPool, params->firstQuery);
31914 }
31915
31916 #ifdef _WIN64
31917 static void thunk64_vkCmdWriteBufferMarker2AMD(void *args)
31918 {
31919     struct vkCmdWriteBufferMarker2AMD_params *params = args;
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 }
31923 #endif /* _WIN64 */
31924
31925 static void thunk32_vkCmdWriteBufferMarker2AMD(void *args)
31926 {
31927     struct
31928     {
31929         PTR32 commandBuffer;
31930         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
31931         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
31932         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
31933         uint32_t marker;
31934     } *params = args;
31935
31936     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteBufferMarker2AMD(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stage, params->dstBuffer, params->dstOffset, params->marker);
31937 }
31938
31939 #ifdef _WIN64
31940 static void thunk64_vkCmdWriteBufferMarkerAMD(void *args)
31941 {
31942     struct vkCmdWriteBufferMarkerAMD_params *params = args;
31943
31944     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);
31945 }
31946 #endif /* _WIN64 */
31947
31948 static void thunk32_vkCmdWriteBufferMarkerAMD(void *args)
31949 {
31950     struct
31951     {
31952         PTR32 commandBuffer;
31953         VkPipelineStageFlagBits pipelineStage;
31954         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
31955         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
31956         uint32_t marker;
31957     } *params = args;
31958
31959     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteBufferMarkerAMD(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineStage, params->dstBuffer, params->dstOffset, params->marker);
31960 }
31961
31962 #ifdef _WIN64
31963 static void thunk64_vkCmdWriteMicromapsPropertiesEXT(void *args)
31964 {
31965     struct vkCmdWriteMicromapsPropertiesEXT_params *params = args;
31966
31967     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);
31968 }
31969 #endif /* _WIN64 */
31970
31971 static void thunk32_vkCmdWriteMicromapsPropertiesEXT(void *args)
31972 {
31973     struct
31974     {
31975         PTR32 commandBuffer;
31976         uint32_t micromapCount;
31977         PTR32 pMicromaps;
31978         VkQueryType queryType;
31979         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
31980         uint32_t firstQuery;
31981     } *params = args;
31982
31983     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteMicromapsPropertiesEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->micromapCount, (const VkMicromapEXT *)UlongToPtr(params->pMicromaps), params->queryType, params->queryPool, params->firstQuery);
31984 }
31985
31986 #ifdef _WIN64
31987 static void thunk64_vkCmdWriteTimestamp(void *args)
31988 {
31989     struct vkCmdWriteTimestamp_params *params = args;
31990
31991     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);
31992 }
31993 #endif /* _WIN64 */
31994
31995 static void thunk32_vkCmdWriteTimestamp(void *args)
31996 {
31997     struct
31998     {
31999         PTR32 commandBuffer;
32000         VkPipelineStageFlagBits pipelineStage;
32001         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
32002         uint32_t query;
32003     } *params = args;
32004
32005     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteTimestamp(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineStage, params->queryPool, params->query);
32006 }
32007
32008 #ifdef _WIN64
32009 static void thunk64_vkCmdWriteTimestamp2(void *args)
32010 {
32011     struct vkCmdWriteTimestamp2_params *params = args;
32012
32013     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);
32014 }
32015 #endif /* _WIN64 */
32016
32017 static void thunk32_vkCmdWriteTimestamp2(void *args)
32018 {
32019     struct
32020     {
32021         PTR32 commandBuffer;
32022         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
32023         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
32024         uint32_t query;
32025     } *params = args;
32026
32027     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteTimestamp2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stage, params->queryPool, params->query);
32028 }
32029
32030 #ifdef _WIN64
32031 static void thunk64_vkCmdWriteTimestamp2KHR(void *args)
32032 {
32033     struct vkCmdWriteTimestamp2KHR_params *params = args;
32034
32035     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);
32036 }
32037 #endif /* _WIN64 */
32038
32039 static void thunk32_vkCmdWriteTimestamp2KHR(void *args)
32040 {
32041     struct
32042     {
32043         PTR32 commandBuffer;
32044         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
32045         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
32046         uint32_t query;
32047     } *params = args;
32048
32049     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteTimestamp2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stage, params->queryPool, params->query);
32050 }
32051
32052 #ifdef _WIN64
32053 static NTSTATUS thunk64_vkCompileDeferredNV(void *args)
32054 {
32055     struct vkCompileDeferredNV_params *params = args;
32056
32057     TRACE("%p, 0x%s, %u\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shader);
32058
32059     params->result = wine_device_from_handle(params->device)->funcs.p_vkCompileDeferredNV(wine_device_from_handle(params->device)->device, params->pipeline, params->shader);
32060     return STATUS_SUCCESS;
32061 }
32062 #endif /* _WIN64 */
32063
32064 static NTSTATUS thunk32_vkCompileDeferredNV(void *args)
32065 {
32066     struct
32067     {
32068         PTR32 device;
32069         VkPipeline DECLSPEC_ALIGN(8) pipeline;
32070         uint32_t shader;
32071         VkResult result;
32072     } *params = args;
32073
32074     TRACE("%#x, 0x%s, %u\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shader);
32075
32076     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCompileDeferredNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipeline, params->shader);
32077     return STATUS_SUCCESS;
32078 }
32079
32080 #ifdef _WIN64
32081 static NTSTATUS thunk64_vkCopyAccelerationStructureKHR(void *args)
32082 {
32083     struct vkCopyAccelerationStructureKHR_params *params = args;
32084
32085     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32086
32087     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
32088     return STATUS_SUCCESS;
32089 }
32090 #endif /* _WIN64 */
32091
32092 static NTSTATUS thunk32_vkCopyAccelerationStructureKHR(void *args)
32093 {
32094     struct
32095     {
32096         PTR32 device;
32097         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
32098         PTR32 pInfo;
32099         VkResult result;
32100     } *params = args;
32101     VkCopyAccelerationStructureInfoKHR pInfo_host;
32102
32103     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32104
32105     convert_VkCopyAccelerationStructureInfoKHR_win32_to_host((const VkCopyAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
32106     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyAccelerationStructureKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, &pInfo_host);
32107     return STATUS_SUCCESS;
32108 }
32109
32110 #ifdef _WIN64
32111 static NTSTATUS thunk64_vkCopyAccelerationStructureToMemoryKHR(void *args)
32112 {
32113     struct vkCopyAccelerationStructureToMemoryKHR_params *params = args;
32114
32115     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32116
32117     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureToMemoryKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
32118     return STATUS_SUCCESS;
32119 }
32120 #endif /* _WIN64 */
32121
32122 static NTSTATUS thunk32_vkCopyAccelerationStructureToMemoryKHR(void *args)
32123 {
32124     struct
32125     {
32126         PTR32 device;
32127         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
32128         PTR32 pInfo;
32129         VkResult result;
32130     } *params = args;
32131     VkCopyAccelerationStructureToMemoryInfoKHR pInfo_host;
32132
32133     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32134
32135     convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host((const VkCopyAccelerationStructureToMemoryInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
32136     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyAccelerationStructureToMemoryKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, &pInfo_host);
32137     return STATUS_SUCCESS;
32138 }
32139
32140 #ifdef _WIN64
32141 static NTSTATUS thunk64_vkCopyMemoryToAccelerationStructureKHR(void *args)
32142 {
32143     struct vkCopyMemoryToAccelerationStructureKHR_params *params = args;
32144
32145     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32146
32147     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
32148     return STATUS_SUCCESS;
32149 }
32150 #endif /* _WIN64 */
32151
32152 static NTSTATUS thunk32_vkCopyMemoryToAccelerationStructureKHR(void *args)
32153 {
32154     struct
32155     {
32156         PTR32 device;
32157         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
32158         PTR32 pInfo;
32159         VkResult result;
32160     } *params = args;
32161     VkCopyMemoryToAccelerationStructureInfoKHR pInfo_host;
32162
32163     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32164
32165     convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host((const VkCopyMemoryToAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
32166     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyMemoryToAccelerationStructureKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, &pInfo_host);
32167     return STATUS_SUCCESS;
32168 }
32169
32170 #ifdef _WIN64
32171 static NTSTATUS thunk64_vkCopyMemoryToMicromapEXT(void *args)
32172 {
32173     struct vkCopyMemoryToMicromapEXT_params *params = args;
32174
32175     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32176
32177     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
32178     return STATUS_SUCCESS;
32179 }
32180 #endif /* _WIN64 */
32181
32182 static NTSTATUS thunk32_vkCopyMemoryToMicromapEXT(void *args)
32183 {
32184     struct
32185     {
32186         PTR32 device;
32187         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
32188         PTR32 pInfo;
32189         VkResult result;
32190     } *params = args;
32191     VkCopyMemoryToMicromapInfoEXT pInfo_host;
32192
32193     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32194
32195     convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host((const VkCopyMemoryToMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
32196     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyMemoryToMicromapEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, &pInfo_host);
32197     return STATUS_SUCCESS;
32198 }
32199
32200 #ifdef _WIN64
32201 static NTSTATUS thunk64_vkCopyMicromapEXT(void *args)
32202 {
32203     struct vkCopyMicromapEXT_params *params = args;
32204
32205     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32206
32207     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
32208     return STATUS_SUCCESS;
32209 }
32210 #endif /* _WIN64 */
32211
32212 static NTSTATUS thunk32_vkCopyMicromapEXT(void *args)
32213 {
32214     struct
32215     {
32216         PTR32 device;
32217         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
32218         PTR32 pInfo;
32219         VkResult result;
32220     } *params = args;
32221     VkCopyMicromapInfoEXT pInfo_host;
32222
32223     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32224
32225     convert_VkCopyMicromapInfoEXT_win32_to_host((const VkCopyMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
32226     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyMicromapEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, &pInfo_host);
32227     return STATUS_SUCCESS;
32228 }
32229
32230 #ifdef _WIN64
32231 static NTSTATUS thunk64_vkCopyMicromapToMemoryEXT(void *args)
32232 {
32233     struct vkCopyMicromapToMemoryEXT_params *params = args;
32234
32235     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32236
32237     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapToMemoryEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
32238     return STATUS_SUCCESS;
32239 }
32240 #endif /* _WIN64 */
32241
32242 static NTSTATUS thunk32_vkCopyMicromapToMemoryEXT(void *args)
32243 {
32244     struct
32245     {
32246         PTR32 device;
32247         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
32248         PTR32 pInfo;
32249         VkResult result;
32250     } *params = args;
32251     VkCopyMicromapToMemoryInfoEXT pInfo_host;
32252
32253     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32254
32255     convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host((const VkCopyMicromapToMemoryInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
32256     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyMicromapToMemoryEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, &pInfo_host);
32257     return STATUS_SUCCESS;
32258 }
32259
32260 #ifdef _WIN64
32261 static NTSTATUS thunk64_vkCreateAccelerationStructureKHR(void *args)
32262 {
32263     struct vkCreateAccelerationStructureKHR_params *params = args;
32264
32265     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
32266
32267     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pAccelerationStructure);
32268     return STATUS_SUCCESS;
32269 }
32270 #endif /* _WIN64 */
32271
32272 static NTSTATUS thunk32_vkCreateAccelerationStructureKHR(void *args)
32273 {
32274     struct
32275     {
32276         PTR32 device;
32277         PTR32 pCreateInfo;
32278         PTR32 pAllocator;
32279         PTR32 pAccelerationStructure;
32280         VkResult result;
32281     } *params = args;
32282     VkAccelerationStructureCreateInfoKHR pCreateInfo_host;
32283     struct conversion_context ctx;
32284
32285     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
32286
32287     init_conversion_context(&ctx);
32288     convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(&ctx, (const VkAccelerationStructureCreateInfoKHR32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32289     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateAccelerationStructureKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkAccelerationStructureKHR *)UlongToPtr(params->pAccelerationStructure));
32290     free_conversion_context(&ctx);
32291     return STATUS_SUCCESS;
32292 }
32293
32294 #ifdef _WIN64
32295 static NTSTATUS thunk64_vkCreateAccelerationStructureNV(void *args)
32296 {
32297     struct vkCreateAccelerationStructureNV_params *params = args;
32298
32299     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
32300
32301     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pAccelerationStructure);
32302     return STATUS_SUCCESS;
32303 }
32304 #endif /* _WIN64 */
32305
32306 static NTSTATUS thunk32_vkCreateAccelerationStructureNV(void *args)
32307 {
32308     struct
32309     {
32310         PTR32 device;
32311         PTR32 pCreateInfo;
32312         PTR32 pAllocator;
32313         PTR32 pAccelerationStructure;
32314         VkResult result;
32315     } *params = args;
32316     VkAccelerationStructureCreateInfoNV pCreateInfo_host;
32317     struct conversion_context ctx;
32318
32319     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
32320
32321     init_conversion_context(&ctx);
32322     convert_VkAccelerationStructureCreateInfoNV_win32_to_host(&ctx, (const VkAccelerationStructureCreateInfoNV32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32323     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateAccelerationStructureNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkAccelerationStructureNV *)UlongToPtr(params->pAccelerationStructure));
32324     free_conversion_context(&ctx);
32325     return STATUS_SUCCESS;
32326 }
32327
32328 #ifdef _WIN64
32329 static NTSTATUS thunk64_vkCreateBuffer(void *args)
32330 {
32331     struct vkCreateBuffer_params *params = args;
32332
32333     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pBuffer);
32334
32335     params->result = wine_vkCreateBuffer(params->device, params->pCreateInfo, params->pAllocator, params->pBuffer);
32336     return STATUS_SUCCESS;
32337 }
32338 #endif /* _WIN64 */
32339
32340 static NTSTATUS thunk32_vkCreateBuffer(void *args)
32341 {
32342     struct
32343     {
32344         PTR32 device;
32345         PTR32 pCreateInfo;
32346         PTR32 pAllocator;
32347         PTR32 pBuffer;
32348         VkResult result;
32349     } *params = args;
32350     VkBufferCreateInfo pCreateInfo_host;
32351     struct conversion_context ctx;
32352
32353     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pBuffer);
32354
32355     init_conversion_context(&ctx);
32356     convert_VkBufferCreateInfo_win32_to_host(&ctx, (const VkBufferCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32357     params->result = wine_vkCreateBuffer((VkDevice)UlongToPtr(params->device), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkBuffer *)UlongToPtr(params->pBuffer));
32358     free_conversion_context(&ctx);
32359     return STATUS_SUCCESS;
32360 }
32361
32362 #ifdef _WIN64
32363 static NTSTATUS thunk64_vkCreateBufferView(void *args)
32364 {
32365     struct vkCreateBufferView_params *params = args;
32366
32367     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
32368
32369     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateBufferView(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pView);
32370     return STATUS_SUCCESS;
32371 }
32372 #endif /* _WIN64 */
32373
32374 static NTSTATUS thunk32_vkCreateBufferView(void *args)
32375 {
32376     struct
32377     {
32378         PTR32 device;
32379         PTR32 pCreateInfo;
32380         PTR32 pAllocator;
32381         PTR32 pView;
32382         VkResult result;
32383     } *params = args;
32384     VkBufferViewCreateInfo pCreateInfo_host;
32385
32386     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
32387
32388     convert_VkBufferViewCreateInfo_win32_to_host((const VkBufferViewCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32389     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateBufferView(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkBufferView *)UlongToPtr(params->pView));
32390     return STATUS_SUCCESS;
32391 }
32392
32393 #ifdef _WIN64
32394 static NTSTATUS thunk64_vkCreateCommandPool(void *args)
32395 {
32396     struct vkCreateCommandPool_params *params = args;
32397
32398     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool);
32399
32400     params->result = wine_vkCreateCommandPool(params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool, params->client_ptr);
32401     return STATUS_SUCCESS;
32402 }
32403 #endif /* _WIN64 */
32404
32405 static NTSTATUS thunk32_vkCreateCommandPool(void *args)
32406 {
32407     struct
32408     {
32409         PTR32 device;
32410         PTR32 pCreateInfo;
32411         PTR32 pAllocator;
32412         PTR32 pCommandPool;
32413         PTR32 client_ptr;
32414         VkResult result;
32415     } *params = args;
32416     VkCommandPoolCreateInfo pCreateInfo_host;
32417
32418     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool);
32419
32420     convert_VkCommandPoolCreateInfo_win32_to_host((const VkCommandPoolCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32421     params->result = wine_vkCreateCommandPool((VkDevice)UlongToPtr(params->device), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkCommandPool *)UlongToPtr(params->pCommandPool), UlongToPtr(params->client_ptr));
32422     return STATUS_SUCCESS;
32423 }
32424
32425 #ifdef _WIN64
32426 static NTSTATUS thunk64_vkCreateComputePipelines(void *args)
32427 {
32428     struct vkCreateComputePipelines_params *params = args;
32429     const VkComputePipelineCreateInfo *pCreateInfos_host;
32430     struct conversion_context ctx;
32431
32432     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
32433
32434     init_conversion_context(&ctx);
32435     pCreateInfos_host = convert_VkComputePipelineCreateInfo_array_win64_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
32436     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);
32437     free_conversion_context(&ctx);
32438     return STATUS_SUCCESS;
32439 }
32440 #endif /* _WIN64 */
32441
32442 static NTSTATUS thunk32_vkCreateComputePipelines(void *args)
32443 {
32444     struct
32445     {
32446         PTR32 device;
32447         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
32448         uint32_t createInfoCount;
32449         PTR32 pCreateInfos;
32450         PTR32 pAllocator;
32451         PTR32 pPipelines;
32452         VkResult result;
32453     } *params = args;
32454     const VkComputePipelineCreateInfo *pCreateInfos_host;
32455     struct conversion_context ctx;
32456
32457     TRACE("%#x, 0x%s, %u, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
32458
32459     init_conversion_context(&ctx);
32460     pCreateInfos_host = convert_VkComputePipelineCreateInfo_array_win32_to_host(&ctx, (const VkComputePipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
32461     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateComputePipelines(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, (VkPipeline *)UlongToPtr(params->pPipelines));
32462     convert_VkComputePipelineCreateInfo_array_host_to_win32(pCreateInfos_host, (const VkComputePipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
32463     free_conversion_context(&ctx);
32464     return STATUS_SUCCESS;
32465 }
32466
32467 #ifdef _WIN64
32468 static NTSTATUS thunk64_vkCreateCuFunctionNVX(void *args)
32469 {
32470     struct vkCreateCuFunctionNVX_params *params = args;
32471
32472     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFunction);
32473
32474     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuFunctionNVX(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFunction);
32475     return STATUS_SUCCESS;
32476 }
32477 #endif /* _WIN64 */
32478
32479 static NTSTATUS thunk32_vkCreateCuFunctionNVX(void *args)
32480 {
32481     struct
32482     {
32483         PTR32 device;
32484         PTR32 pCreateInfo;
32485         PTR32 pAllocator;
32486         PTR32 pFunction;
32487         VkResult result;
32488     } *params = args;
32489     VkCuFunctionCreateInfoNVX pCreateInfo_host;
32490
32491     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pFunction);
32492
32493     convert_VkCuFunctionCreateInfoNVX_win32_to_host((const VkCuFunctionCreateInfoNVX32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32494     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateCuFunctionNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkCuFunctionNVX *)UlongToPtr(params->pFunction));
32495     return STATUS_SUCCESS;
32496 }
32497
32498 #ifdef _WIN64
32499 static NTSTATUS thunk64_vkCreateCuModuleNVX(void *args)
32500 {
32501     struct vkCreateCuModuleNVX_params *params = args;
32502
32503     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pModule);
32504
32505     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuModuleNVX(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pModule);
32506     return STATUS_SUCCESS;
32507 }
32508 #endif /* _WIN64 */
32509
32510 static NTSTATUS thunk32_vkCreateCuModuleNVX(void *args)
32511 {
32512     struct
32513     {
32514         PTR32 device;
32515         PTR32 pCreateInfo;
32516         PTR32 pAllocator;
32517         PTR32 pModule;
32518         VkResult result;
32519     } *params = args;
32520     VkCuModuleCreateInfoNVX pCreateInfo_host;
32521
32522     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pModule);
32523
32524     convert_VkCuModuleCreateInfoNVX_win32_to_host((const VkCuModuleCreateInfoNVX32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32525     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateCuModuleNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkCuModuleNVX *)UlongToPtr(params->pModule));
32526     return STATUS_SUCCESS;
32527 }
32528
32529 #ifdef _WIN64
32530 static NTSTATUS thunk64_vkCreateDebugReportCallbackEXT(void *args)
32531 {
32532     struct vkCreateDebugReportCallbackEXT_params *params = args;
32533
32534     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
32535
32536     params->result = wine_vkCreateDebugReportCallbackEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
32537     return STATUS_SUCCESS;
32538 }
32539 #endif /* _WIN64 */
32540
32541 static NTSTATUS thunk32_vkCreateDebugReportCallbackEXT(void *args)
32542 {
32543     struct
32544     {
32545         PTR32 instance;
32546         PTR32 pCreateInfo;
32547         PTR32 pAllocator;
32548         PTR32 pCallback;
32549         VkResult result;
32550     } *params = args;
32551     VkDebugReportCallbackCreateInfoEXT pCreateInfo_host;
32552
32553     TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
32554
32555     convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host((const VkDebugReportCallbackCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32556     params->result = wine_vkCreateDebugReportCallbackEXT((VkInstance)UlongToPtr(params->instance), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkDebugReportCallbackEXT *)UlongToPtr(params->pCallback));
32557     return STATUS_SUCCESS;
32558 }
32559
32560 #ifdef _WIN64
32561 static NTSTATUS thunk64_vkCreateDebugUtilsMessengerEXT(void *args)
32562 {
32563     struct vkCreateDebugUtilsMessengerEXT_params *params = args;
32564
32565     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
32566
32567     params->result = wine_vkCreateDebugUtilsMessengerEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
32568     return STATUS_SUCCESS;
32569 }
32570 #endif /* _WIN64 */
32571
32572 static NTSTATUS thunk32_vkCreateDebugUtilsMessengerEXT(void *args)
32573 {
32574     struct
32575     {
32576         PTR32 instance;
32577         PTR32 pCreateInfo;
32578         PTR32 pAllocator;
32579         PTR32 pMessenger;
32580         VkResult result;
32581     } *params = args;
32582     VkDebugUtilsMessengerCreateInfoEXT pCreateInfo_host;
32583
32584     TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
32585
32586     convert_VkDebugUtilsMessengerCreateInfoEXT_win32_to_host((const VkDebugUtilsMessengerCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32587     params->result = wine_vkCreateDebugUtilsMessengerEXT((VkInstance)UlongToPtr(params->instance), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkDebugUtilsMessengerEXT *)UlongToPtr(params->pMessenger));
32588     return STATUS_SUCCESS;
32589 }
32590
32591 #ifdef _WIN64
32592 static NTSTATUS thunk64_vkCreateDeferredOperationKHR(void *args)
32593 {
32594     struct vkCreateDeferredOperationKHR_params *params = args;
32595
32596     TRACE("%p, %p, %p\n", params->device, params->pAllocator, params->pDeferredOperation);
32597
32598     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDeferredOperationKHR(wine_device_from_handle(params->device)->device, NULL, params->pDeferredOperation);
32599     return STATUS_SUCCESS;
32600 }
32601 #endif /* _WIN64 */
32602
32603 static NTSTATUS thunk32_vkCreateDeferredOperationKHR(void *args)
32604 {
32605     struct
32606     {
32607         PTR32 device;
32608         PTR32 pAllocator;
32609         PTR32 pDeferredOperation;
32610         VkResult result;
32611     } *params = args;
32612
32613     TRACE("%#x, %#x, %#x\n", params->device, params->pAllocator, params->pDeferredOperation);
32614
32615     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateDeferredOperationKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, NULL, (VkDeferredOperationKHR *)UlongToPtr(params->pDeferredOperation));
32616     return STATUS_SUCCESS;
32617 }
32618
32619 #ifdef _WIN64
32620 static NTSTATUS thunk64_vkCreateDescriptorPool(void *args)
32621 {
32622     struct vkCreateDescriptorPool_params *params = args;
32623
32624     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorPool);
32625
32626     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorPool);
32627     return STATUS_SUCCESS;
32628 }
32629 #endif /* _WIN64 */
32630
32631 static NTSTATUS thunk32_vkCreateDescriptorPool(void *args)
32632 {
32633     struct
32634     {
32635         PTR32 device;
32636         PTR32 pCreateInfo;
32637         PTR32 pAllocator;
32638         PTR32 pDescriptorPool;
32639         VkResult result;
32640     } *params = args;
32641     VkDescriptorPoolCreateInfo pCreateInfo_host;
32642     struct conversion_context ctx;
32643
32644     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorPool);
32645
32646     init_conversion_context(&ctx);
32647     convert_VkDescriptorPoolCreateInfo_win32_to_host(&ctx, (const VkDescriptorPoolCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32648     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateDescriptorPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkDescriptorPool *)UlongToPtr(params->pDescriptorPool));
32649     free_conversion_context(&ctx);
32650     return STATUS_SUCCESS;
32651 }
32652
32653 #ifdef _WIN64
32654 static NTSTATUS thunk64_vkCreateDescriptorSetLayout(void *args)
32655 {
32656     struct vkCreateDescriptorSetLayout_params *params = args;
32657
32658     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSetLayout);
32659
32660     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSetLayout);
32661     return STATUS_SUCCESS;
32662 }
32663 #endif /* _WIN64 */
32664
32665 static NTSTATUS thunk32_vkCreateDescriptorSetLayout(void *args)
32666 {
32667     struct
32668     {
32669         PTR32 device;
32670         PTR32 pCreateInfo;
32671         PTR32 pAllocator;
32672         PTR32 pSetLayout;
32673         VkResult result;
32674     } *params = args;
32675     VkDescriptorSetLayoutCreateInfo pCreateInfo_host;
32676     struct conversion_context ctx;
32677
32678     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSetLayout);
32679
32680     init_conversion_context(&ctx);
32681     convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(&ctx, (const VkDescriptorSetLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32682     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateDescriptorSetLayout(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkDescriptorSetLayout *)UlongToPtr(params->pSetLayout));
32683     free_conversion_context(&ctx);
32684     return STATUS_SUCCESS;
32685 }
32686
32687 #ifdef _WIN64
32688 static NTSTATUS thunk64_vkCreateDescriptorUpdateTemplate(void *args)
32689 {
32690     struct vkCreateDescriptorUpdateTemplate_params *params = args;
32691
32692     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
32693
32694     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorUpdateTemplate);
32695     return STATUS_SUCCESS;
32696 }
32697 #endif /* _WIN64 */
32698
32699 static NTSTATUS thunk32_vkCreateDescriptorUpdateTemplate(void *args)
32700 {
32701     struct
32702     {
32703         PTR32 device;
32704         PTR32 pCreateInfo;
32705         PTR32 pAllocator;
32706         PTR32 pDescriptorUpdateTemplate;
32707         VkResult result;
32708     } *params = args;
32709     VkDescriptorUpdateTemplateCreateInfo pCreateInfo_host;
32710     struct conversion_context ctx;
32711
32712     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
32713
32714     init_conversion_context(&ctx);
32715     convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(&ctx, (const VkDescriptorUpdateTemplateCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32716     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateDescriptorUpdateTemplate(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkDescriptorUpdateTemplate *)UlongToPtr(params->pDescriptorUpdateTemplate));
32717     free_conversion_context(&ctx);
32718     return STATUS_SUCCESS;
32719 }
32720
32721 #ifdef _WIN64
32722 static NTSTATUS thunk64_vkCreateDescriptorUpdateTemplateKHR(void *args)
32723 {
32724     struct vkCreateDescriptorUpdateTemplateKHR_params *params = args;
32725
32726     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
32727
32728     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorUpdateTemplate);
32729     return STATUS_SUCCESS;
32730 }
32731 #endif /* _WIN64 */
32732
32733 static NTSTATUS thunk32_vkCreateDescriptorUpdateTemplateKHR(void *args)
32734 {
32735     struct
32736     {
32737         PTR32 device;
32738         PTR32 pCreateInfo;
32739         PTR32 pAllocator;
32740         PTR32 pDescriptorUpdateTemplate;
32741         VkResult result;
32742     } *params = args;
32743     VkDescriptorUpdateTemplateCreateInfo pCreateInfo_host;
32744     struct conversion_context ctx;
32745
32746     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
32747
32748     init_conversion_context(&ctx);
32749     convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(&ctx, (const VkDescriptorUpdateTemplateCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32750     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateDescriptorUpdateTemplateKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkDescriptorUpdateTemplate *)UlongToPtr(params->pDescriptorUpdateTemplate));
32751     free_conversion_context(&ctx);
32752     return STATUS_SUCCESS;
32753 }
32754
32755 #ifdef _WIN64
32756 static NTSTATUS thunk64_vkCreateDevice(void *args)
32757 {
32758     struct vkCreateDevice_params *params = args;
32759     VkDeviceCreateInfo pCreateInfo_host;
32760     struct conversion_context ctx;
32761
32762     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice);
32763
32764     init_conversion_context(&ctx);
32765     convert_VkDeviceCreateInfo_win64_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
32766     params->result = wine_vkCreateDevice(params->physicalDevice, &pCreateInfo_host, params->pAllocator, params->pDevice, params->client_ptr);
32767     free_conversion_context(&ctx);
32768     return STATUS_SUCCESS;
32769 }
32770 #endif /* _WIN64 */
32771
32772 static NTSTATUS thunk32_vkCreateDevice(void *args)
32773 {
32774     struct
32775     {
32776         PTR32 physicalDevice;
32777         PTR32 pCreateInfo;
32778         PTR32 pAllocator;
32779         PTR32 pDevice;
32780         PTR32 client_ptr;
32781         VkResult result;
32782     } *params = args;
32783     VkDeviceCreateInfo pCreateInfo_host;
32784     VkDevice pDevice_host;
32785     struct conversion_context ctx;
32786
32787     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice);
32788
32789     init_conversion_context(&ctx);
32790     convert_VkDeviceCreateInfo_win32_to_host(&ctx, (const VkDeviceCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32791     pDevice_host = UlongToPtr(*(PTR32 *)UlongToPtr(params->pDevice));
32792     params->result = wine_vkCreateDevice((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), &pDevice_host, UlongToPtr(params->client_ptr));
32793     *(PTR32 *)UlongToPtr(params->pDevice) = PtrToUlong(pDevice_host);
32794     free_conversion_context(&ctx);
32795     return STATUS_SUCCESS;
32796 }
32797
32798 #ifdef _WIN64
32799 static NTSTATUS thunk64_vkCreateEvent(void *args)
32800 {
32801     struct vkCreateEvent_params *params = args;
32802
32803     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pEvent);
32804
32805     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateEvent(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pEvent);
32806     return STATUS_SUCCESS;
32807 }
32808 #endif /* _WIN64 */
32809
32810 static NTSTATUS thunk32_vkCreateEvent(void *args)
32811 {
32812     struct
32813     {
32814         PTR32 device;
32815         PTR32 pCreateInfo;
32816         PTR32 pAllocator;
32817         PTR32 pEvent;
32818         VkResult result;
32819     } *params = args;
32820     VkEventCreateInfo pCreateInfo_host;
32821
32822     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pEvent);
32823
32824     convert_VkEventCreateInfo_win32_to_host((const VkEventCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32825     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateEvent(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkEvent *)UlongToPtr(params->pEvent));
32826     return STATUS_SUCCESS;
32827 }
32828
32829 #ifdef _WIN64
32830 static NTSTATUS thunk64_vkCreateFence(void *args)
32831 {
32832     struct vkCreateFence_params *params = args;
32833
32834     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFence);
32835
32836     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFence(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFence);
32837     return STATUS_SUCCESS;
32838 }
32839 #endif /* _WIN64 */
32840
32841 static NTSTATUS thunk32_vkCreateFence(void *args)
32842 {
32843     struct
32844     {
32845         PTR32 device;
32846         PTR32 pCreateInfo;
32847         PTR32 pAllocator;
32848         PTR32 pFence;
32849         VkResult result;
32850     } *params = args;
32851     VkFenceCreateInfo pCreateInfo_host;
32852     struct conversion_context ctx;
32853
32854     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pFence);
32855
32856     init_conversion_context(&ctx);
32857     convert_VkFenceCreateInfo_win32_to_host(&ctx, (const VkFenceCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32858     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateFence(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkFence *)UlongToPtr(params->pFence));
32859     free_conversion_context(&ctx);
32860     return STATUS_SUCCESS;
32861 }
32862
32863 #ifdef _WIN64
32864 static NTSTATUS thunk64_vkCreateFramebuffer(void *args)
32865 {
32866     struct vkCreateFramebuffer_params *params = args;
32867
32868     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFramebuffer);
32869
32870     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFramebuffer(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFramebuffer);
32871     return STATUS_SUCCESS;
32872 }
32873 #endif /* _WIN64 */
32874
32875 static NTSTATUS thunk32_vkCreateFramebuffer(void *args)
32876 {
32877     struct
32878     {
32879         PTR32 device;
32880         PTR32 pCreateInfo;
32881         PTR32 pAllocator;
32882         PTR32 pFramebuffer;
32883         VkResult result;
32884     } *params = args;
32885     VkFramebufferCreateInfo pCreateInfo_host;
32886     struct conversion_context ctx;
32887
32888     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pFramebuffer);
32889
32890     init_conversion_context(&ctx);
32891     convert_VkFramebufferCreateInfo_win32_to_host(&ctx, (const VkFramebufferCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32892     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateFramebuffer(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkFramebuffer *)UlongToPtr(params->pFramebuffer));
32893     free_conversion_context(&ctx);
32894     return STATUS_SUCCESS;
32895 }
32896
32897 #ifdef _WIN64
32898 static NTSTATUS thunk64_vkCreateGraphicsPipelines(void *args)
32899 {
32900     struct vkCreateGraphicsPipelines_params *params = args;
32901     const VkGraphicsPipelineCreateInfo *pCreateInfos_host;
32902     struct conversion_context ctx;
32903
32904     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
32905
32906     init_conversion_context(&ctx);
32907     pCreateInfos_host = convert_VkGraphicsPipelineCreateInfo_array_win64_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
32908     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);
32909     free_conversion_context(&ctx);
32910     return STATUS_SUCCESS;
32911 }
32912 #endif /* _WIN64 */
32913
32914 static NTSTATUS thunk32_vkCreateGraphicsPipelines(void *args)
32915 {
32916     struct
32917     {
32918         PTR32 device;
32919         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
32920         uint32_t createInfoCount;
32921         PTR32 pCreateInfos;
32922         PTR32 pAllocator;
32923         PTR32 pPipelines;
32924         VkResult result;
32925     } *params = args;
32926     const VkGraphicsPipelineCreateInfo *pCreateInfos_host;
32927     struct conversion_context ctx;
32928
32929     TRACE("%#x, 0x%s, %u, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
32930
32931     init_conversion_context(&ctx);
32932     pCreateInfos_host = convert_VkGraphicsPipelineCreateInfo_array_win32_to_host(&ctx, (const VkGraphicsPipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
32933     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateGraphicsPipelines(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, (VkPipeline *)UlongToPtr(params->pPipelines));
32934     convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(pCreateInfos_host, (const VkGraphicsPipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
32935     free_conversion_context(&ctx);
32936     return STATUS_SUCCESS;
32937 }
32938
32939 #ifdef _WIN64
32940 static NTSTATUS thunk64_vkCreateImage(void *args)
32941 {
32942     struct vkCreateImage_params *params = args;
32943
32944     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pImage);
32945
32946     params->result = wine_vkCreateImage(params->device, params->pCreateInfo, params->pAllocator, params->pImage);
32947     return STATUS_SUCCESS;
32948 }
32949 #endif /* _WIN64 */
32950
32951 static NTSTATUS thunk32_vkCreateImage(void *args)
32952 {
32953     struct
32954     {
32955         PTR32 device;
32956         PTR32 pCreateInfo;
32957         PTR32 pAllocator;
32958         PTR32 pImage;
32959         VkResult result;
32960     } *params = args;
32961     VkImageCreateInfo pCreateInfo_host;
32962     struct conversion_context ctx;
32963
32964     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pImage);
32965
32966     init_conversion_context(&ctx);
32967     convert_VkImageCreateInfo_win32_to_host(&ctx, (const VkImageCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32968     params->result = wine_vkCreateImage((VkDevice)UlongToPtr(params->device), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkImage *)UlongToPtr(params->pImage));
32969     free_conversion_context(&ctx);
32970     return STATUS_SUCCESS;
32971 }
32972
32973 #ifdef _WIN64
32974 static NTSTATUS thunk64_vkCreateImageView(void *args)
32975 {
32976     struct vkCreateImageView_params *params = args;
32977
32978     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
32979
32980     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateImageView(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pView);
32981     return STATUS_SUCCESS;
32982 }
32983 #endif /* _WIN64 */
32984
32985 static NTSTATUS thunk32_vkCreateImageView(void *args)
32986 {
32987     struct
32988     {
32989         PTR32 device;
32990         PTR32 pCreateInfo;
32991         PTR32 pAllocator;
32992         PTR32 pView;
32993         VkResult result;
32994     } *params = args;
32995     VkImageViewCreateInfo pCreateInfo_host;
32996     struct conversion_context ctx;
32997
32998     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
32999
33000     init_conversion_context(&ctx);
33001     convert_VkImageViewCreateInfo_win32_to_host(&ctx, (const VkImageViewCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33002     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateImageView(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkImageView *)UlongToPtr(params->pView));
33003     free_conversion_context(&ctx);
33004     return STATUS_SUCCESS;
33005 }
33006
33007 #ifdef _WIN64
33008 static NTSTATUS thunk64_vkCreateIndirectCommandsLayoutNV(void *args)
33009 {
33010     struct vkCreateIndirectCommandsLayoutNV_params *params = args;
33011
33012     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout);
33013
33014     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pIndirectCommandsLayout);
33015     return STATUS_SUCCESS;
33016 }
33017 #endif /* _WIN64 */
33018
33019 static NTSTATUS thunk32_vkCreateIndirectCommandsLayoutNV(void *args)
33020 {
33021     struct
33022     {
33023         PTR32 device;
33024         PTR32 pCreateInfo;
33025         PTR32 pAllocator;
33026         PTR32 pIndirectCommandsLayout;
33027         VkResult result;
33028     } *params = args;
33029     VkIndirectCommandsLayoutCreateInfoNV pCreateInfo_host;
33030     struct conversion_context ctx;
33031
33032     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout);
33033
33034     init_conversion_context(&ctx);
33035     convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(&ctx, (const VkIndirectCommandsLayoutCreateInfoNV32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33036     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateIndirectCommandsLayoutNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkIndirectCommandsLayoutNV *)UlongToPtr(params->pIndirectCommandsLayout));
33037     free_conversion_context(&ctx);
33038     return STATUS_SUCCESS;
33039 }
33040
33041 #ifdef _WIN64
33042 static NTSTATUS thunk64_vkCreateInstance(void *args)
33043 {
33044     struct vkCreateInstance_params *params = args;
33045     VkInstanceCreateInfo pCreateInfo_host;
33046     struct conversion_context ctx;
33047
33048     TRACE("%p, %p, %p\n", params->pCreateInfo, params->pAllocator, params->pInstance);
33049
33050     init_conversion_context(&ctx);
33051     convert_VkInstanceCreateInfo_win64_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
33052     params->result = wine_vkCreateInstance(&pCreateInfo_host, params->pAllocator, params->pInstance, params->client_ptr);
33053     free_conversion_context(&ctx);
33054     return STATUS_SUCCESS;
33055 }
33056 #endif /* _WIN64 */
33057
33058 static NTSTATUS thunk32_vkCreateInstance(void *args)
33059 {
33060     struct
33061     {
33062         PTR32 pCreateInfo;
33063         PTR32 pAllocator;
33064         PTR32 pInstance;
33065         PTR32 client_ptr;
33066         VkResult result;
33067     } *params = args;
33068     VkInstanceCreateInfo pCreateInfo_host;
33069     VkInstance pInstance_host;
33070     struct conversion_context ctx;
33071
33072     TRACE("%#x, %#x, %#x\n", params->pCreateInfo, params->pAllocator, params->pInstance);
33073
33074     init_conversion_context(&ctx);
33075     convert_VkInstanceCreateInfo_win32_to_host(&ctx, (const VkInstanceCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33076     pInstance_host = UlongToPtr(*(PTR32 *)UlongToPtr(params->pInstance));
33077     params->result = wine_vkCreateInstance(&pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), &pInstance_host, UlongToPtr(params->client_ptr));
33078     *(PTR32 *)UlongToPtr(params->pInstance) = PtrToUlong(pInstance_host);
33079     free_conversion_context(&ctx);
33080     return STATUS_SUCCESS;
33081 }
33082
33083 #ifdef _WIN64
33084 static NTSTATUS thunk64_vkCreateMicromapEXT(void *args)
33085 {
33086     struct vkCreateMicromapEXT_params *params = args;
33087
33088     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pMicromap);
33089
33090     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateMicromapEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pMicromap);
33091     return STATUS_SUCCESS;
33092 }
33093 #endif /* _WIN64 */
33094
33095 static NTSTATUS thunk32_vkCreateMicromapEXT(void *args)
33096 {
33097     struct
33098     {
33099         PTR32 device;
33100         PTR32 pCreateInfo;
33101         PTR32 pAllocator;
33102         PTR32 pMicromap;
33103         VkResult result;
33104     } *params = args;
33105     VkMicromapCreateInfoEXT pCreateInfo_host;
33106
33107     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pMicromap);
33108
33109     convert_VkMicromapCreateInfoEXT_win32_to_host((const VkMicromapCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33110     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateMicromapEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkMicromapEXT *)UlongToPtr(params->pMicromap));
33111     return STATUS_SUCCESS;
33112 }
33113
33114 #ifdef _WIN64
33115 static NTSTATUS thunk64_vkCreateOpticalFlowSessionNV(void *args)
33116 {
33117     struct vkCreateOpticalFlowSessionNV_params *params = args;
33118
33119     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSession);
33120
33121     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSession);
33122     return STATUS_SUCCESS;
33123 }
33124 #endif /* _WIN64 */
33125
33126 static NTSTATUS thunk32_vkCreateOpticalFlowSessionNV(void *args)
33127 {
33128     struct
33129     {
33130         PTR32 device;
33131         PTR32 pCreateInfo;
33132         PTR32 pAllocator;
33133         PTR32 pSession;
33134         VkResult result;
33135     } *params = args;
33136     VkOpticalFlowSessionCreateInfoNV pCreateInfo_host;
33137     struct conversion_context ctx;
33138
33139     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSession);
33140
33141     init_conversion_context(&ctx);
33142     convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(&ctx, (const VkOpticalFlowSessionCreateInfoNV32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33143     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateOpticalFlowSessionNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkOpticalFlowSessionNV *)UlongToPtr(params->pSession));
33144     free_conversion_context(&ctx);
33145     return STATUS_SUCCESS;
33146 }
33147
33148 #ifdef _WIN64
33149 static NTSTATUS thunk64_vkCreatePipelineCache(void *args)
33150 {
33151     struct vkCreatePipelineCache_params *params = args;
33152
33153     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineCache);
33154
33155     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineCache(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineCache);
33156     return STATUS_SUCCESS;
33157 }
33158 #endif /* _WIN64 */
33159
33160 static NTSTATUS thunk32_vkCreatePipelineCache(void *args)
33161 {
33162     struct
33163     {
33164         PTR32 device;
33165         PTR32 pCreateInfo;
33166         PTR32 pAllocator;
33167         PTR32 pPipelineCache;
33168         VkResult result;
33169     } *params = args;
33170     VkPipelineCacheCreateInfo pCreateInfo_host;
33171
33172     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineCache);
33173
33174     convert_VkPipelineCacheCreateInfo_win32_to_host((const VkPipelineCacheCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33175     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreatePipelineCache(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkPipelineCache *)UlongToPtr(params->pPipelineCache));
33176     return STATUS_SUCCESS;
33177 }
33178
33179 #ifdef _WIN64
33180 static NTSTATUS thunk64_vkCreatePipelineLayout(void *args)
33181 {
33182     struct vkCreatePipelineLayout_params *params = args;
33183
33184     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineLayout);
33185
33186     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineLayout);
33187     return STATUS_SUCCESS;
33188 }
33189 #endif /* _WIN64 */
33190
33191 static NTSTATUS thunk32_vkCreatePipelineLayout(void *args)
33192 {
33193     struct
33194     {
33195         PTR32 device;
33196         PTR32 pCreateInfo;
33197         PTR32 pAllocator;
33198         PTR32 pPipelineLayout;
33199         VkResult result;
33200     } *params = args;
33201     VkPipelineLayoutCreateInfo pCreateInfo_host;
33202
33203     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineLayout);
33204
33205     convert_VkPipelineLayoutCreateInfo_win32_to_host((const VkPipelineLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33206     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreatePipelineLayout(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkPipelineLayout *)UlongToPtr(params->pPipelineLayout));
33207     return STATUS_SUCCESS;
33208 }
33209
33210 #ifdef _WIN64
33211 static NTSTATUS thunk64_vkCreatePrivateDataSlot(void *args)
33212 {
33213     struct vkCreatePrivateDataSlot_params *params = args;
33214
33215     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
33216
33217     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlot(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
33218     return STATUS_SUCCESS;
33219 }
33220 #endif /* _WIN64 */
33221
33222 static NTSTATUS thunk32_vkCreatePrivateDataSlot(void *args)
33223 {
33224     struct
33225     {
33226         PTR32 device;
33227         PTR32 pCreateInfo;
33228         PTR32 pAllocator;
33229         PTR32 pPrivateDataSlot;
33230         VkResult result;
33231     } *params = args;
33232     VkPrivateDataSlotCreateInfo pCreateInfo_host;
33233
33234     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
33235
33236     convert_VkPrivateDataSlotCreateInfo_win32_to_host((const VkPrivateDataSlotCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33237     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreatePrivateDataSlot(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkPrivateDataSlot *)UlongToPtr(params->pPrivateDataSlot));
33238     return STATUS_SUCCESS;
33239 }
33240
33241 #ifdef _WIN64
33242 static NTSTATUS thunk64_vkCreatePrivateDataSlotEXT(void *args)
33243 {
33244     struct vkCreatePrivateDataSlotEXT_params *params = args;
33245
33246     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
33247
33248     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
33249     return STATUS_SUCCESS;
33250 }
33251 #endif /* _WIN64 */
33252
33253 static NTSTATUS thunk32_vkCreatePrivateDataSlotEXT(void *args)
33254 {
33255     struct
33256     {
33257         PTR32 device;
33258         PTR32 pCreateInfo;
33259         PTR32 pAllocator;
33260         PTR32 pPrivateDataSlot;
33261         VkResult result;
33262     } *params = args;
33263     VkPrivateDataSlotCreateInfo pCreateInfo_host;
33264
33265     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
33266
33267     convert_VkPrivateDataSlotCreateInfo_win32_to_host((const VkPrivateDataSlotCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33268     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreatePrivateDataSlotEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkPrivateDataSlot *)UlongToPtr(params->pPrivateDataSlot));
33269     return STATUS_SUCCESS;
33270 }
33271
33272 #ifdef _WIN64
33273 static NTSTATUS thunk64_vkCreateQueryPool(void *args)
33274 {
33275     struct vkCreateQueryPool_params *params = args;
33276
33277     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pQueryPool);
33278
33279     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateQueryPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pQueryPool);
33280     return STATUS_SUCCESS;
33281 }
33282 #endif /* _WIN64 */
33283
33284 static NTSTATUS thunk32_vkCreateQueryPool(void *args)
33285 {
33286     struct
33287     {
33288         PTR32 device;
33289         PTR32 pCreateInfo;
33290         PTR32 pAllocator;
33291         PTR32 pQueryPool;
33292         VkResult result;
33293     } *params = args;
33294     VkQueryPoolCreateInfo pCreateInfo_host;
33295     struct conversion_context ctx;
33296
33297     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pQueryPool);
33298
33299     init_conversion_context(&ctx);
33300     convert_VkQueryPoolCreateInfo_win32_to_host(&ctx, (const VkQueryPoolCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33301     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateQueryPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkQueryPool *)UlongToPtr(params->pQueryPool));
33302     free_conversion_context(&ctx);
33303     return STATUS_SUCCESS;
33304 }
33305
33306 #ifdef _WIN64
33307 static NTSTATUS thunk64_vkCreateRayTracingPipelinesKHR(void *args)
33308 {
33309     struct vkCreateRayTracingPipelinesKHR_params *params = args;
33310     const VkRayTracingPipelineCreateInfoKHR *pCreateInfos_host;
33311     struct conversion_context ctx;
33312
33313     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);
33314
33315     init_conversion_context(&ctx);
33316     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoKHR_array_win64_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
33317     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);
33318     free_conversion_context(&ctx);
33319     return STATUS_SUCCESS;
33320 }
33321 #endif /* _WIN64 */
33322
33323 static NTSTATUS thunk32_vkCreateRayTracingPipelinesKHR(void *args)
33324 {
33325     struct
33326     {
33327         PTR32 device;
33328         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
33329         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
33330         uint32_t createInfoCount;
33331         PTR32 pCreateInfos;
33332         PTR32 pAllocator;
33333         PTR32 pPipelines;
33334         VkResult result;
33335     } *params = args;
33336     const VkRayTracingPipelineCreateInfoKHR *pCreateInfos_host;
33337     struct conversion_context ctx;
33338
33339     TRACE("%#x, 0x%s, 0x%s, %u, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
33340
33341     init_conversion_context(&ctx);
33342     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(&ctx, (const VkRayTracingPipelineCreateInfoKHR32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
33343     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateRayTracingPipelinesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, (VkPipeline *)UlongToPtr(params->pPipelines));
33344     convert_VkRayTracingPipelineCreateInfoKHR_array_host_to_win32(pCreateInfos_host, (const VkRayTracingPipelineCreateInfoKHR32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
33345     free_conversion_context(&ctx);
33346     return STATUS_SUCCESS;
33347 }
33348
33349 #ifdef _WIN64
33350 static NTSTATUS thunk64_vkCreateRayTracingPipelinesNV(void *args)
33351 {
33352     struct vkCreateRayTracingPipelinesNV_params *params = args;
33353     const VkRayTracingPipelineCreateInfoNV *pCreateInfos_host;
33354     struct conversion_context ctx;
33355
33356     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
33357
33358     init_conversion_context(&ctx);
33359     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoNV_array_win64_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
33360     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);
33361     free_conversion_context(&ctx);
33362     return STATUS_SUCCESS;
33363 }
33364 #endif /* _WIN64 */
33365
33366 static NTSTATUS thunk32_vkCreateRayTracingPipelinesNV(void *args)
33367 {
33368     struct
33369     {
33370         PTR32 device;
33371         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
33372         uint32_t createInfoCount;
33373         PTR32 pCreateInfos;
33374         PTR32 pAllocator;
33375         PTR32 pPipelines;
33376         VkResult result;
33377     } *params = args;
33378     const VkRayTracingPipelineCreateInfoNV *pCreateInfos_host;
33379     struct conversion_context ctx;
33380
33381     TRACE("%#x, 0x%s, %u, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
33382
33383     init_conversion_context(&ctx);
33384     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoNV_array_win32_to_host(&ctx, (const VkRayTracingPipelineCreateInfoNV32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
33385     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateRayTracingPipelinesNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, (VkPipeline *)UlongToPtr(params->pPipelines));
33386     convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32(pCreateInfos_host, (const VkRayTracingPipelineCreateInfoNV32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
33387     free_conversion_context(&ctx);
33388     return STATUS_SUCCESS;
33389 }
33390
33391 #ifdef _WIN64
33392 static NTSTATUS thunk64_vkCreateRenderPass(void *args)
33393 {
33394     struct vkCreateRenderPass_params *params = args;
33395
33396     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33397
33398     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
33399     return STATUS_SUCCESS;
33400 }
33401 #endif /* _WIN64 */
33402
33403 static NTSTATUS thunk32_vkCreateRenderPass(void *args)
33404 {
33405     struct
33406     {
33407         PTR32 device;
33408         PTR32 pCreateInfo;
33409         PTR32 pAllocator;
33410         PTR32 pRenderPass;
33411         VkResult result;
33412     } *params = args;
33413     VkRenderPassCreateInfo pCreateInfo_host;
33414     struct conversion_context ctx;
33415
33416     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33417
33418     init_conversion_context(&ctx);
33419     convert_VkRenderPassCreateInfo_win32_to_host(&ctx, (const VkRenderPassCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33420     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateRenderPass(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkRenderPass *)UlongToPtr(params->pRenderPass));
33421     free_conversion_context(&ctx);
33422     return STATUS_SUCCESS;
33423 }
33424
33425 #ifdef _WIN64
33426 static NTSTATUS thunk64_vkCreateRenderPass2(void *args)
33427 {
33428     struct vkCreateRenderPass2_params *params = args;
33429
33430     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33431
33432     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
33433     return STATUS_SUCCESS;
33434 }
33435 #endif /* _WIN64 */
33436
33437 static NTSTATUS thunk32_vkCreateRenderPass2(void *args)
33438 {
33439     struct
33440     {
33441         PTR32 device;
33442         PTR32 pCreateInfo;
33443         PTR32 pAllocator;
33444         PTR32 pRenderPass;
33445         VkResult result;
33446     } *params = args;
33447     VkRenderPassCreateInfo2 pCreateInfo_host;
33448     struct conversion_context ctx;
33449
33450     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33451
33452     init_conversion_context(&ctx);
33453     convert_VkRenderPassCreateInfo2_win32_to_host(&ctx, (const VkRenderPassCreateInfo232 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33454     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateRenderPass2(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkRenderPass *)UlongToPtr(params->pRenderPass));
33455     free_conversion_context(&ctx);
33456     return STATUS_SUCCESS;
33457 }
33458
33459 #ifdef _WIN64
33460 static NTSTATUS thunk64_vkCreateRenderPass2KHR(void *args)
33461 {
33462     struct vkCreateRenderPass2KHR_params *params = args;
33463
33464     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33465
33466     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2KHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
33467     return STATUS_SUCCESS;
33468 }
33469 #endif /* _WIN64 */
33470
33471 static NTSTATUS thunk32_vkCreateRenderPass2KHR(void *args)
33472 {
33473     struct
33474     {
33475         PTR32 device;
33476         PTR32 pCreateInfo;
33477         PTR32 pAllocator;
33478         PTR32 pRenderPass;
33479         VkResult result;
33480     } *params = args;
33481     VkRenderPassCreateInfo2 pCreateInfo_host;
33482     struct conversion_context ctx;
33483
33484     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33485
33486     init_conversion_context(&ctx);
33487     convert_VkRenderPassCreateInfo2_win32_to_host(&ctx, (const VkRenderPassCreateInfo232 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33488     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateRenderPass2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkRenderPass *)UlongToPtr(params->pRenderPass));
33489     free_conversion_context(&ctx);
33490     return STATUS_SUCCESS;
33491 }
33492
33493 #ifdef _WIN64
33494 static NTSTATUS thunk64_vkCreateSampler(void *args)
33495 {
33496     struct vkCreateSampler_params *params = args;
33497
33498     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSampler);
33499
33500     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSampler(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSampler);
33501     return STATUS_SUCCESS;
33502 }
33503 #endif /* _WIN64 */
33504
33505 static NTSTATUS thunk32_vkCreateSampler(void *args)
33506 {
33507     struct
33508     {
33509         PTR32 device;
33510         PTR32 pCreateInfo;
33511         PTR32 pAllocator;
33512         PTR32 pSampler;
33513         VkResult result;
33514     } *params = args;
33515     VkSamplerCreateInfo pCreateInfo_host;
33516     struct conversion_context ctx;
33517
33518     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSampler);
33519
33520     init_conversion_context(&ctx);
33521     convert_VkSamplerCreateInfo_win32_to_host(&ctx, (const VkSamplerCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33522     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateSampler(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkSampler *)UlongToPtr(params->pSampler));
33523     free_conversion_context(&ctx);
33524     return STATUS_SUCCESS;
33525 }
33526
33527 #ifdef _WIN64
33528 static NTSTATUS thunk64_vkCreateSamplerYcbcrConversion(void *args)
33529 {
33530     struct vkCreateSamplerYcbcrConversion_params *params = args;
33531
33532     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
33533
33534     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
33535     return STATUS_SUCCESS;
33536 }
33537 #endif /* _WIN64 */
33538
33539 static NTSTATUS thunk32_vkCreateSamplerYcbcrConversion(void *args)
33540 {
33541     struct
33542     {
33543         PTR32 device;
33544         PTR32 pCreateInfo;
33545         PTR32 pAllocator;
33546         PTR32 pYcbcrConversion;
33547         VkResult result;
33548     } *params = args;
33549     VkSamplerYcbcrConversionCreateInfo pCreateInfo_host;
33550
33551     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
33552
33553     convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host((const VkSamplerYcbcrConversionCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33554     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateSamplerYcbcrConversion(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkSamplerYcbcrConversion *)UlongToPtr(params->pYcbcrConversion));
33555     return STATUS_SUCCESS;
33556 }
33557
33558 #ifdef _WIN64
33559 static NTSTATUS thunk64_vkCreateSamplerYcbcrConversionKHR(void *args)
33560 {
33561     struct vkCreateSamplerYcbcrConversionKHR_params *params = args;
33562
33563     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
33564
33565     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
33566     return STATUS_SUCCESS;
33567 }
33568 #endif /* _WIN64 */
33569
33570 static NTSTATUS thunk32_vkCreateSamplerYcbcrConversionKHR(void *args)
33571 {
33572     struct
33573     {
33574         PTR32 device;
33575         PTR32 pCreateInfo;
33576         PTR32 pAllocator;
33577         PTR32 pYcbcrConversion;
33578         VkResult result;
33579     } *params = args;
33580     VkSamplerYcbcrConversionCreateInfo pCreateInfo_host;
33581
33582     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
33583
33584     convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host((const VkSamplerYcbcrConversionCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33585     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateSamplerYcbcrConversionKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkSamplerYcbcrConversion *)UlongToPtr(params->pYcbcrConversion));
33586     return STATUS_SUCCESS;
33587 }
33588
33589 #ifdef _WIN64
33590 static NTSTATUS thunk64_vkCreateSemaphore(void *args)
33591 {
33592     struct vkCreateSemaphore_params *params = args;
33593
33594     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSemaphore);
33595
33596     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSemaphore(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSemaphore);
33597     return STATUS_SUCCESS;
33598 }
33599 #endif /* _WIN64 */
33600
33601 static NTSTATUS thunk32_vkCreateSemaphore(void *args)
33602 {
33603     struct
33604     {
33605         PTR32 device;
33606         PTR32 pCreateInfo;
33607         PTR32 pAllocator;
33608         PTR32 pSemaphore;
33609         VkResult result;
33610     } *params = args;
33611     VkSemaphoreCreateInfo pCreateInfo_host;
33612     struct conversion_context ctx;
33613
33614     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSemaphore);
33615
33616     init_conversion_context(&ctx);
33617     convert_VkSemaphoreCreateInfo_win32_to_host(&ctx, (const VkSemaphoreCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33618     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateSemaphore(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkSemaphore *)UlongToPtr(params->pSemaphore));
33619     free_conversion_context(&ctx);
33620     return STATUS_SUCCESS;
33621 }
33622
33623 #ifdef _WIN64
33624 static NTSTATUS thunk64_vkCreateShaderModule(void *args)
33625 {
33626     struct vkCreateShaderModule_params *params = args;
33627
33628     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pShaderModule);
33629
33630     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateShaderModule(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pShaderModule);
33631     return STATUS_SUCCESS;
33632 }
33633 #endif /* _WIN64 */
33634
33635 static NTSTATUS thunk32_vkCreateShaderModule(void *args)
33636 {
33637     struct
33638     {
33639         PTR32 device;
33640         PTR32 pCreateInfo;
33641         PTR32 pAllocator;
33642         PTR32 pShaderModule;
33643         VkResult result;
33644     } *params = args;
33645     VkShaderModuleCreateInfo pCreateInfo_host;
33646     struct conversion_context ctx;
33647
33648     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pShaderModule);
33649
33650     init_conversion_context(&ctx);
33651     convert_VkShaderModuleCreateInfo_win32_to_host(&ctx, (const VkShaderModuleCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33652     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateShaderModule(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkShaderModule *)UlongToPtr(params->pShaderModule));
33653     free_conversion_context(&ctx);
33654     return STATUS_SUCCESS;
33655 }
33656
33657 #ifdef _WIN64
33658 static NTSTATUS thunk64_vkCreateShadersEXT(void *args)
33659 {
33660     struct vkCreateShadersEXT_params *params = args;
33661
33662     TRACE("%p, %u, %p, %p, %p\n", params->device, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pShaders);
33663
33664     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateShadersEXT(wine_device_from_handle(params->device)->device, params->createInfoCount, params->pCreateInfos, NULL, params->pShaders);
33665     return STATUS_SUCCESS;
33666 }
33667 #endif /* _WIN64 */
33668
33669 static NTSTATUS thunk32_vkCreateShadersEXT(void *args)
33670 {
33671     struct
33672     {
33673         PTR32 device;
33674         uint32_t createInfoCount;
33675         PTR32 pCreateInfos;
33676         PTR32 pAllocator;
33677         PTR32 pShaders;
33678         VkResult result;
33679     } *params = args;
33680     const VkShaderCreateInfoEXT *pCreateInfos_host;
33681     struct conversion_context ctx;
33682
33683     TRACE("%#x, %u, %#x, %#x, %#x\n", params->device, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pShaders);
33684
33685     init_conversion_context(&ctx);
33686     pCreateInfos_host = convert_VkShaderCreateInfoEXT_array_win32_to_host(&ctx, (const VkShaderCreateInfoEXT32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
33687     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateShadersEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->createInfoCount, pCreateInfos_host, NULL, (VkShaderEXT *)UlongToPtr(params->pShaders));
33688     free_conversion_context(&ctx);
33689     return STATUS_SUCCESS;
33690 }
33691
33692 #ifdef _WIN64
33693 static NTSTATUS thunk64_vkCreateSwapchainKHR(void *args)
33694 {
33695     struct vkCreateSwapchainKHR_params *params = args;
33696     VkSwapchainCreateInfoKHR pCreateInfo_host;
33697
33698     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSwapchain);
33699
33700     convert_VkSwapchainCreateInfoKHR_win64_to_host(params->pCreateInfo, &pCreateInfo_host);
33701     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSwapchainKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSwapchain);
33702     return STATUS_SUCCESS;
33703 }
33704 #endif /* _WIN64 */
33705
33706 static NTSTATUS thunk32_vkCreateSwapchainKHR(void *args)
33707 {
33708     struct
33709     {
33710         PTR32 device;
33711         PTR32 pCreateInfo;
33712         PTR32 pAllocator;
33713         PTR32 pSwapchain;
33714         VkResult result;
33715     } *params = args;
33716     VkSwapchainCreateInfoKHR pCreateInfo_host;
33717     struct conversion_context ctx;
33718
33719     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSwapchain);
33720
33721     init_conversion_context(&ctx);
33722     convert_VkSwapchainCreateInfoKHR_win32_to_host(&ctx, (const VkSwapchainCreateInfoKHR32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33723     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateSwapchainKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkSwapchainKHR *)UlongToPtr(params->pSwapchain));
33724     free_conversion_context(&ctx);
33725     return STATUS_SUCCESS;
33726 }
33727
33728 #ifdef _WIN64
33729 static NTSTATUS thunk64_vkCreateValidationCacheEXT(void *args)
33730 {
33731     struct vkCreateValidationCacheEXT_params *params = args;
33732
33733     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pValidationCache);
33734
33735     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateValidationCacheEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pValidationCache);
33736     return STATUS_SUCCESS;
33737 }
33738 #endif /* _WIN64 */
33739
33740 static NTSTATUS thunk32_vkCreateValidationCacheEXT(void *args)
33741 {
33742     struct
33743     {
33744         PTR32 device;
33745         PTR32 pCreateInfo;
33746         PTR32 pAllocator;
33747         PTR32 pValidationCache;
33748         VkResult result;
33749     } *params = args;
33750     VkValidationCacheCreateInfoEXT pCreateInfo_host;
33751
33752     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pValidationCache);
33753
33754     convert_VkValidationCacheCreateInfoEXT_win32_to_host((const VkValidationCacheCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33755     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateValidationCacheEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkValidationCacheEXT *)UlongToPtr(params->pValidationCache));
33756     return STATUS_SUCCESS;
33757 }
33758
33759 #ifdef _WIN64
33760 static NTSTATUS thunk64_vkCreateWin32SurfaceKHR(void *args)
33761 {
33762     struct vkCreateWin32SurfaceKHR_params *params = args;
33763
33764     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
33765
33766     params->result = wine_vkCreateWin32SurfaceKHR(params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
33767     return STATUS_SUCCESS;
33768 }
33769 #endif /* _WIN64 */
33770
33771 static NTSTATUS thunk32_vkCreateWin32SurfaceKHR(void *args)
33772 {
33773     struct
33774     {
33775         PTR32 instance;
33776         PTR32 pCreateInfo;
33777         PTR32 pAllocator;
33778         PTR32 pSurface;
33779         VkResult result;
33780     } *params = args;
33781     VkWin32SurfaceCreateInfoKHR pCreateInfo_host;
33782
33783     TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
33784
33785     convert_VkWin32SurfaceCreateInfoKHR_win32_to_host((const VkWin32SurfaceCreateInfoKHR32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33786     params->result = wine_vkCreateWin32SurfaceKHR((VkInstance)UlongToPtr(params->instance), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkSurfaceKHR *)UlongToPtr(params->pSurface));
33787     return STATUS_SUCCESS;
33788 }
33789
33790 #ifdef _WIN64
33791 static NTSTATUS thunk64_vkDebugMarkerSetObjectNameEXT(void *args)
33792 {
33793     struct vkDebugMarkerSetObjectNameEXT_params *params = args;
33794     VkDebugMarkerObjectNameInfoEXT pNameInfo_host;
33795
33796     TRACE("%p, %p\n", params->device, params->pNameInfo);
33797
33798     convert_VkDebugMarkerObjectNameInfoEXT_win64_to_host(params->pNameInfo, &pNameInfo_host);
33799     params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
33800     return STATUS_SUCCESS;
33801 }
33802 #endif /* _WIN64 */
33803
33804 static NTSTATUS thunk32_vkDebugMarkerSetObjectNameEXT(void *args)
33805 {
33806     struct
33807     {
33808         PTR32 device;
33809         PTR32 pNameInfo;
33810         VkResult result;
33811     } *params = args;
33812     VkDebugMarkerObjectNameInfoEXT pNameInfo_host;
33813
33814     TRACE("%#x, %#x\n", params->device, params->pNameInfo);
33815
33816     convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host((const VkDebugMarkerObjectNameInfoEXT32 *)UlongToPtr(params->pNameInfo), &pNameInfo_host);
33817     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDebugMarkerSetObjectNameEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pNameInfo_host);
33818     return STATUS_SUCCESS;
33819 }
33820
33821 #ifdef _WIN64
33822 static NTSTATUS thunk64_vkDebugMarkerSetObjectTagEXT(void *args)
33823 {
33824     struct vkDebugMarkerSetObjectTagEXT_params *params = args;
33825     VkDebugMarkerObjectTagInfoEXT pTagInfo_host;
33826
33827     TRACE("%p, %p\n", params->device, params->pTagInfo);
33828
33829     convert_VkDebugMarkerObjectTagInfoEXT_win64_to_host(params->pTagInfo, &pTagInfo_host);
33830     params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
33831     return STATUS_SUCCESS;
33832 }
33833 #endif /* _WIN64 */
33834
33835 static NTSTATUS thunk32_vkDebugMarkerSetObjectTagEXT(void *args)
33836 {
33837     struct
33838     {
33839         PTR32 device;
33840         PTR32 pTagInfo;
33841         VkResult result;
33842     } *params = args;
33843     VkDebugMarkerObjectTagInfoEXT pTagInfo_host;
33844
33845     TRACE("%#x, %#x\n", params->device, params->pTagInfo);
33846
33847     convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host((const VkDebugMarkerObjectTagInfoEXT32 *)UlongToPtr(params->pTagInfo), &pTagInfo_host);
33848     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDebugMarkerSetObjectTagEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pTagInfo_host);
33849     return STATUS_SUCCESS;
33850 }
33851
33852 #ifdef _WIN64
33853 static NTSTATUS thunk64_vkDebugReportMessageEXT(void *args)
33854 {
33855     struct vkDebugReportMessageEXT_params *params = args;
33856
33857     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);
33858
33859     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);
33860     return STATUS_SUCCESS;
33861 }
33862 #endif /* _WIN64 */
33863
33864 static NTSTATUS thunk32_vkDebugReportMessageEXT(void *args)
33865 {
33866     struct
33867     {
33868         PTR32 instance;
33869         VkDebugReportFlagsEXT flags;
33870         VkDebugReportObjectTypeEXT objectType;
33871         uint64_t DECLSPEC_ALIGN(8) object;
33872         PTR32 location;
33873         int32_t messageCode;
33874         PTR32 pLayerPrefix;
33875         PTR32 pMessage;
33876     } *params = args;
33877
33878     TRACE("%#x, %#x, %#x, 0x%s, 0x%s, %d, %#x, %#x\n", params->instance, params->flags, params->objectType, wine_dbgstr_longlong(params->object), wine_dbgstr_longlong(params->location), params->messageCode, params->pLayerPrefix, params->pMessage);
33879
33880     wine_instance_from_handle((VkInstance)UlongToPtr(params->instance))->funcs.p_vkDebugReportMessageEXT(wine_instance_from_handle((VkInstance)UlongToPtr(params->instance))->instance, params->flags, params->objectType, wine_vk_unwrap_handle(params->objectType, params->object), params->location, params->messageCode, (const char *)UlongToPtr(params->pLayerPrefix), (const char *)UlongToPtr(params->pMessage));
33881     return STATUS_SUCCESS;
33882 }
33883
33884 #ifdef _WIN64
33885 static NTSTATUS thunk64_vkDeferredOperationJoinKHR(void *args)
33886 {
33887     struct vkDeferredOperationJoinKHR_params *params = args;
33888
33889     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
33890
33891     params->result = wine_device_from_handle(params->device)->funcs.p_vkDeferredOperationJoinKHR(wine_device_from_handle(params->device)->device, params->operation);
33892     return STATUS_SUCCESS;
33893 }
33894 #endif /* _WIN64 */
33895
33896 static NTSTATUS thunk32_vkDeferredOperationJoinKHR(void *args)
33897 {
33898     struct
33899     {
33900         PTR32 device;
33901         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
33902         VkResult result;
33903     } *params = args;
33904
33905     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
33906
33907     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDeferredOperationJoinKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->operation);
33908     return STATUS_SUCCESS;
33909 }
33910
33911 #ifdef _WIN64
33912 static NTSTATUS thunk64_vkDestroyAccelerationStructureKHR(void *args)
33913 {
33914     struct vkDestroyAccelerationStructureKHR_params *params = args;
33915
33916     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
33917
33918     wine_device_from_handle(params->device)->funcs.p_vkDestroyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->accelerationStructure, NULL);
33919     return STATUS_SUCCESS;
33920 }
33921 #endif /* _WIN64 */
33922
33923 static NTSTATUS thunk32_vkDestroyAccelerationStructureKHR(void *args)
33924 {
33925     struct
33926     {
33927         PTR32 device;
33928         VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
33929         PTR32 pAllocator;
33930     } *params = args;
33931
33932     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
33933
33934     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyAccelerationStructureKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->accelerationStructure, NULL);
33935     return STATUS_SUCCESS;
33936 }
33937
33938 #ifdef _WIN64
33939 static NTSTATUS thunk64_vkDestroyAccelerationStructureNV(void *args)
33940 {
33941     struct vkDestroyAccelerationStructureNV_params *params = args;
33942
33943     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
33944
33945     wine_device_from_handle(params->device)->funcs.p_vkDestroyAccelerationStructureNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, NULL);
33946     return STATUS_SUCCESS;
33947 }
33948 #endif /* _WIN64 */
33949
33950 static NTSTATUS thunk32_vkDestroyAccelerationStructureNV(void *args)
33951 {
33952     struct
33953     {
33954         PTR32 device;
33955         VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
33956         PTR32 pAllocator;
33957     } *params = args;
33958
33959     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
33960
33961     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyAccelerationStructureNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->accelerationStructure, NULL);
33962     return STATUS_SUCCESS;
33963 }
33964
33965 #ifdef _WIN64
33966 static NTSTATUS thunk64_vkDestroyBuffer(void *args)
33967 {
33968     struct vkDestroyBuffer_params *params = args;
33969
33970     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->buffer), params->pAllocator);
33971
33972     wine_device_from_handle(params->device)->funcs.p_vkDestroyBuffer(wine_device_from_handle(params->device)->device, params->buffer, NULL);
33973     return STATUS_SUCCESS;
33974 }
33975 #endif /* _WIN64 */
33976
33977 static NTSTATUS thunk32_vkDestroyBuffer(void *args)
33978 {
33979     struct
33980     {
33981         PTR32 device;
33982         VkBuffer DECLSPEC_ALIGN(8) buffer;
33983         PTR32 pAllocator;
33984     } *params = args;
33985
33986     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->buffer), params->pAllocator);
33987
33988     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyBuffer(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->buffer, NULL);
33989     return STATUS_SUCCESS;
33990 }
33991
33992 #ifdef _WIN64
33993 static NTSTATUS thunk64_vkDestroyBufferView(void *args)
33994 {
33995     struct vkDestroyBufferView_params *params = args;
33996
33997     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->bufferView), params->pAllocator);
33998
33999     wine_device_from_handle(params->device)->funcs.p_vkDestroyBufferView(wine_device_from_handle(params->device)->device, params->bufferView, NULL);
34000     return STATUS_SUCCESS;
34001 }
34002 #endif /* _WIN64 */
34003
34004 static NTSTATUS thunk32_vkDestroyBufferView(void *args)
34005 {
34006     struct
34007     {
34008         PTR32 device;
34009         VkBufferView DECLSPEC_ALIGN(8) bufferView;
34010         PTR32 pAllocator;
34011     } *params = args;
34012
34013     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->bufferView), params->pAllocator);
34014
34015     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyBufferView(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->bufferView, NULL);
34016     return STATUS_SUCCESS;
34017 }
34018
34019 #ifdef _WIN64
34020 static NTSTATUS thunk64_vkDestroyCommandPool(void *args)
34021 {
34022     struct vkDestroyCommandPool_params *params = args;
34023
34024     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->commandPool), params->pAllocator);
34025
34026     wine_vkDestroyCommandPool(params->device, params->commandPool, params->pAllocator);
34027     return STATUS_SUCCESS;
34028 }
34029 #endif /* _WIN64 */
34030
34031 static NTSTATUS thunk32_vkDestroyCommandPool(void *args)
34032 {
34033     struct
34034     {
34035         PTR32 device;
34036         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
34037         PTR32 pAllocator;
34038     } *params = args;
34039
34040     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->pAllocator);
34041
34042     wine_vkDestroyCommandPool((VkDevice)UlongToPtr(params->device), params->commandPool, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
34043     return STATUS_SUCCESS;
34044 }
34045
34046 #ifdef _WIN64
34047 static NTSTATUS thunk64_vkDestroyCuFunctionNVX(void *args)
34048 {
34049     struct vkDestroyCuFunctionNVX_params *params = args;
34050
34051     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->function), params->pAllocator);
34052
34053     wine_device_from_handle(params->device)->funcs.p_vkDestroyCuFunctionNVX(wine_device_from_handle(params->device)->device, params->function, NULL);
34054     return STATUS_SUCCESS;
34055 }
34056 #endif /* _WIN64 */
34057
34058 static NTSTATUS thunk32_vkDestroyCuFunctionNVX(void *args)
34059 {
34060     struct
34061     {
34062         PTR32 device;
34063         VkCuFunctionNVX DECLSPEC_ALIGN(8) function;
34064         PTR32 pAllocator;
34065     } *params = args;
34066
34067     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->function), params->pAllocator);
34068
34069     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyCuFunctionNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->function, NULL);
34070     return STATUS_SUCCESS;
34071 }
34072
34073 #ifdef _WIN64
34074 static NTSTATUS thunk64_vkDestroyCuModuleNVX(void *args)
34075 {
34076     struct vkDestroyCuModuleNVX_params *params = args;
34077
34078     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->module), params->pAllocator);
34079
34080     wine_device_from_handle(params->device)->funcs.p_vkDestroyCuModuleNVX(wine_device_from_handle(params->device)->device, params->module, NULL);
34081     return STATUS_SUCCESS;
34082 }
34083 #endif /* _WIN64 */
34084
34085 static NTSTATUS thunk32_vkDestroyCuModuleNVX(void *args)
34086 {
34087     struct
34088     {
34089         PTR32 device;
34090         VkCuModuleNVX DECLSPEC_ALIGN(8) module;
34091         PTR32 pAllocator;
34092     } *params = args;
34093
34094     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->module), params->pAllocator);
34095
34096     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyCuModuleNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->module, NULL);
34097     return STATUS_SUCCESS;
34098 }
34099
34100 #ifdef _WIN64
34101 static NTSTATUS thunk64_vkDestroyDebugReportCallbackEXT(void *args)
34102 {
34103     struct vkDestroyDebugReportCallbackEXT_params *params = args;
34104
34105     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->callback), params->pAllocator);
34106
34107     wine_vkDestroyDebugReportCallbackEXT(params->instance, params->callback, params->pAllocator);
34108     return STATUS_SUCCESS;
34109 }
34110 #endif /* _WIN64 */
34111
34112 static NTSTATUS thunk32_vkDestroyDebugReportCallbackEXT(void *args)
34113 {
34114     struct
34115     {
34116         PTR32 instance;
34117         VkDebugReportCallbackEXT DECLSPEC_ALIGN(8) callback;
34118         PTR32 pAllocator;
34119     } *params = args;
34120
34121     TRACE("%#x, 0x%s, %#x\n", params->instance, wine_dbgstr_longlong(params->callback), params->pAllocator);
34122
34123     wine_vkDestroyDebugReportCallbackEXT((VkInstance)UlongToPtr(params->instance), params->callback, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
34124     return STATUS_SUCCESS;
34125 }
34126
34127 #ifdef _WIN64
34128 static NTSTATUS thunk64_vkDestroyDebugUtilsMessengerEXT(void *args)
34129 {
34130     struct vkDestroyDebugUtilsMessengerEXT_params *params = args;
34131
34132     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->messenger), params->pAllocator);
34133
34134     wine_vkDestroyDebugUtilsMessengerEXT(params->instance, params->messenger, params->pAllocator);
34135     return STATUS_SUCCESS;
34136 }
34137 #endif /* _WIN64 */
34138
34139 static NTSTATUS thunk32_vkDestroyDebugUtilsMessengerEXT(void *args)
34140 {
34141     struct
34142     {
34143         PTR32 instance;
34144         VkDebugUtilsMessengerEXT DECLSPEC_ALIGN(8) messenger;
34145         PTR32 pAllocator;
34146     } *params = args;
34147
34148     TRACE("%#x, 0x%s, %#x\n", params->instance, wine_dbgstr_longlong(params->messenger), params->pAllocator);
34149
34150     wine_vkDestroyDebugUtilsMessengerEXT((VkInstance)UlongToPtr(params->instance), params->messenger, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
34151     return STATUS_SUCCESS;
34152 }
34153
34154 #ifdef _WIN64
34155 static NTSTATUS thunk64_vkDestroyDeferredOperationKHR(void *args)
34156 {
34157     struct vkDestroyDeferredOperationKHR_params *params = args;
34158
34159     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->operation), params->pAllocator);
34160
34161     wine_device_from_handle(params->device)->funcs.p_vkDestroyDeferredOperationKHR(wine_device_from_handle(params->device)->device, params->operation, NULL);
34162     return STATUS_SUCCESS;
34163 }
34164 #endif /* _WIN64 */
34165
34166 static NTSTATUS thunk32_vkDestroyDeferredOperationKHR(void *args)
34167 {
34168     struct
34169     {
34170         PTR32 device;
34171         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
34172         PTR32 pAllocator;
34173     } *params = args;
34174
34175     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->operation), params->pAllocator);
34176
34177     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDeferredOperationKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->operation, NULL);
34178     return STATUS_SUCCESS;
34179 }
34180
34181 #ifdef _WIN64
34182 static NTSTATUS thunk64_vkDestroyDescriptorPool(void *args)
34183 {
34184     struct vkDestroyDescriptorPool_params *params = args;
34185
34186     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->pAllocator);
34187
34188     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, NULL);
34189     return STATUS_SUCCESS;
34190 }
34191 #endif /* _WIN64 */
34192
34193 static NTSTATUS thunk32_vkDestroyDescriptorPool(void *args)
34194 {
34195     struct
34196     {
34197         PTR32 device;
34198         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
34199         PTR32 pAllocator;
34200     } *params = args;
34201
34202     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->pAllocator);
34203
34204     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorPool, NULL);
34205     return STATUS_SUCCESS;
34206 }
34207
34208 #ifdef _WIN64
34209 static NTSTATUS thunk64_vkDestroyDescriptorSetLayout(void *args)
34210 {
34211     struct vkDestroyDescriptorSetLayout_params *params = args;
34212
34213     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSetLayout), params->pAllocator);
34214
34215     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->descriptorSetLayout, NULL);
34216     return STATUS_SUCCESS;
34217 }
34218 #endif /* _WIN64 */
34219
34220 static NTSTATUS thunk32_vkDestroyDescriptorSetLayout(void *args)
34221 {
34222     struct
34223     {
34224         PTR32 device;
34225         VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
34226         PTR32 pAllocator;
34227     } *params = args;
34228
34229     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorSetLayout), params->pAllocator);
34230
34231     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorSetLayout(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorSetLayout, NULL);
34232     return STATUS_SUCCESS;
34233 }
34234
34235 #ifdef _WIN64
34236 static NTSTATUS thunk64_vkDestroyDescriptorUpdateTemplate(void *args)
34237 {
34238     struct vkDestroyDescriptorUpdateTemplate_params *params = args;
34239
34240     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
34241
34242     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, params->descriptorUpdateTemplate, NULL);
34243     return STATUS_SUCCESS;
34244 }
34245 #endif /* _WIN64 */
34246
34247 static NTSTATUS thunk32_vkDestroyDescriptorUpdateTemplate(void *args)
34248 {
34249     struct
34250     {
34251         PTR32 device;
34252         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
34253         PTR32 pAllocator;
34254     } *params = args;
34255
34256     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
34257
34258     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorUpdateTemplate(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorUpdateTemplate, NULL);
34259     return STATUS_SUCCESS;
34260 }
34261
34262 #ifdef _WIN64
34263 static NTSTATUS thunk64_vkDestroyDescriptorUpdateTemplateKHR(void *args)
34264 {
34265     struct vkDestroyDescriptorUpdateTemplateKHR_params *params = args;
34266
34267     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
34268
34269     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, params->descriptorUpdateTemplate, NULL);
34270     return STATUS_SUCCESS;
34271 }
34272 #endif /* _WIN64 */
34273
34274 static NTSTATUS thunk32_vkDestroyDescriptorUpdateTemplateKHR(void *args)
34275 {
34276     struct
34277     {
34278         PTR32 device;
34279         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
34280         PTR32 pAllocator;
34281     } *params = args;
34282
34283     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
34284
34285     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorUpdateTemplate, NULL);
34286     return STATUS_SUCCESS;
34287 }
34288
34289 #ifdef _WIN64
34290 static NTSTATUS thunk64_vkDestroyDevice(void *args)
34291 {
34292     struct vkDestroyDevice_params *params = args;
34293
34294     TRACE("%p, %p\n", params->device, params->pAllocator);
34295
34296     if (!params->device)
34297         return STATUS_SUCCESS;
34298
34299     wine_vkDestroyDevice(params->device, params->pAllocator);
34300     return STATUS_SUCCESS;
34301 }
34302 #endif /* _WIN64 */
34303
34304 static NTSTATUS thunk32_vkDestroyDevice(void *args)
34305 {
34306     struct
34307     {
34308         PTR32 device;
34309         PTR32 pAllocator;
34310     } *params = args;
34311
34312     TRACE("%#x, %#x\n", params->device, params->pAllocator);
34313
34314     if (!params->device)
34315         return STATUS_SUCCESS;
34316
34317     wine_vkDestroyDevice((VkDevice)UlongToPtr(params->device), (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
34318     return STATUS_SUCCESS;
34319 }
34320
34321 #ifdef _WIN64
34322 static NTSTATUS thunk64_vkDestroyEvent(void *args)
34323 {
34324     struct vkDestroyEvent_params *params = args;
34325
34326     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->event), params->pAllocator);
34327
34328     wine_device_from_handle(params->device)->funcs.p_vkDestroyEvent(wine_device_from_handle(params->device)->device, params->event, NULL);
34329     return STATUS_SUCCESS;
34330 }
34331 #endif /* _WIN64 */
34332
34333 static NTSTATUS thunk32_vkDestroyEvent(void *args)
34334 {
34335     struct
34336     {
34337         PTR32 device;
34338         VkEvent DECLSPEC_ALIGN(8) event;
34339         PTR32 pAllocator;
34340     } *params = args;
34341
34342     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->event), params->pAllocator);
34343
34344     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyEvent(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event, NULL);
34345     return STATUS_SUCCESS;
34346 }
34347
34348 #ifdef _WIN64
34349 static NTSTATUS thunk64_vkDestroyFence(void *args)
34350 {
34351     struct vkDestroyFence_params *params = args;
34352
34353     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->fence), params->pAllocator);
34354
34355     wine_device_from_handle(params->device)->funcs.p_vkDestroyFence(wine_device_from_handle(params->device)->device, params->fence, NULL);
34356     return STATUS_SUCCESS;
34357 }
34358 #endif /* _WIN64 */
34359
34360 static NTSTATUS thunk32_vkDestroyFence(void *args)
34361 {
34362     struct
34363     {
34364         PTR32 device;
34365         VkFence DECLSPEC_ALIGN(8) fence;
34366         PTR32 pAllocator;
34367     } *params = args;
34368
34369     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->fence), params->pAllocator);
34370
34371     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyFence(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->fence, NULL);
34372     return STATUS_SUCCESS;
34373 }
34374
34375 #ifdef _WIN64
34376 static NTSTATUS thunk64_vkDestroyFramebuffer(void *args)
34377 {
34378     struct vkDestroyFramebuffer_params *params = args;
34379
34380     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pAllocator);
34381
34382     wine_device_from_handle(params->device)->funcs.p_vkDestroyFramebuffer(wine_device_from_handle(params->device)->device, params->framebuffer, NULL);
34383     return STATUS_SUCCESS;
34384 }
34385 #endif /* _WIN64 */
34386
34387 static NTSTATUS thunk32_vkDestroyFramebuffer(void *args)
34388 {
34389     struct
34390     {
34391         PTR32 device;
34392         VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
34393         PTR32 pAllocator;
34394     } *params = args;
34395
34396     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pAllocator);
34397
34398     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyFramebuffer(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->framebuffer, NULL);
34399     return STATUS_SUCCESS;
34400 }
34401
34402 #ifdef _WIN64
34403 static NTSTATUS thunk64_vkDestroyImage(void *args)
34404 {
34405     struct vkDestroyImage_params *params = args;
34406
34407     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pAllocator);
34408
34409     wine_device_from_handle(params->device)->funcs.p_vkDestroyImage(wine_device_from_handle(params->device)->device, params->image, NULL);
34410     return STATUS_SUCCESS;
34411 }
34412 #endif /* _WIN64 */
34413
34414 static NTSTATUS thunk32_vkDestroyImage(void *args)
34415 {
34416     struct
34417     {
34418         PTR32 device;
34419         VkImage DECLSPEC_ALIGN(8) image;
34420         PTR32 pAllocator;
34421     } *params = args;
34422
34423     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pAllocator);
34424
34425     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyImage(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, NULL);
34426     return STATUS_SUCCESS;
34427 }
34428
34429 #ifdef _WIN64
34430 static NTSTATUS thunk64_vkDestroyImageView(void *args)
34431 {
34432     struct vkDestroyImageView_params *params = args;
34433
34434     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pAllocator);
34435
34436     wine_device_from_handle(params->device)->funcs.p_vkDestroyImageView(wine_device_from_handle(params->device)->device, params->imageView, NULL);
34437     return STATUS_SUCCESS;
34438 }
34439 #endif /* _WIN64 */
34440
34441 static NTSTATUS thunk32_vkDestroyImageView(void *args)
34442 {
34443     struct
34444     {
34445         PTR32 device;
34446         VkImageView DECLSPEC_ALIGN(8) imageView;
34447         PTR32 pAllocator;
34448     } *params = args;
34449
34450     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->imageView), params->pAllocator);
34451
34452     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyImageView(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->imageView, NULL);
34453     return STATUS_SUCCESS;
34454 }
34455
34456 #ifdef _WIN64
34457 static NTSTATUS thunk64_vkDestroyIndirectCommandsLayoutNV(void *args)
34458 {
34459     struct vkDestroyIndirectCommandsLayoutNV_params *params = args;
34460
34461     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->indirectCommandsLayout), params->pAllocator);
34462
34463     wine_device_from_handle(params->device)->funcs.p_vkDestroyIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, params->indirectCommandsLayout, NULL);
34464     return STATUS_SUCCESS;
34465 }
34466 #endif /* _WIN64 */
34467
34468 static NTSTATUS thunk32_vkDestroyIndirectCommandsLayoutNV(void *args)
34469 {
34470     struct
34471     {
34472         PTR32 device;
34473         VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
34474         PTR32 pAllocator;
34475     } *params = args;
34476
34477     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->indirectCommandsLayout), params->pAllocator);
34478
34479     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyIndirectCommandsLayoutNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->indirectCommandsLayout, NULL);
34480     return STATUS_SUCCESS;
34481 }
34482
34483 #ifdef _WIN64
34484 static NTSTATUS thunk64_vkDestroyInstance(void *args)
34485 {
34486     struct vkDestroyInstance_params *params = args;
34487
34488     TRACE("%p, %p\n", params->instance, params->pAllocator);
34489
34490     if (!params->instance)
34491         return STATUS_SUCCESS;
34492
34493     wine_vkDestroyInstance(params->instance, params->pAllocator);
34494     return STATUS_SUCCESS;
34495 }
34496 #endif /* _WIN64 */
34497
34498 static NTSTATUS thunk32_vkDestroyInstance(void *args)
34499 {
34500     struct
34501     {
34502         PTR32 instance;
34503         PTR32 pAllocator;
34504     } *params = args;
34505
34506     TRACE("%#x, %#x\n", params->instance, params->pAllocator);
34507
34508     if (!params->instance)
34509         return STATUS_SUCCESS;
34510
34511     wine_vkDestroyInstance((VkInstance)UlongToPtr(params->instance), (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
34512     return STATUS_SUCCESS;
34513 }
34514
34515 #ifdef _WIN64
34516 static NTSTATUS thunk64_vkDestroyMicromapEXT(void *args)
34517 {
34518     struct vkDestroyMicromapEXT_params *params = args;
34519
34520     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->micromap), params->pAllocator);
34521
34522     wine_device_from_handle(params->device)->funcs.p_vkDestroyMicromapEXT(wine_device_from_handle(params->device)->device, params->micromap, NULL);
34523     return STATUS_SUCCESS;
34524 }
34525 #endif /* _WIN64 */
34526
34527 static NTSTATUS thunk32_vkDestroyMicromapEXT(void *args)
34528 {
34529     struct
34530     {
34531         PTR32 device;
34532         VkMicromapEXT DECLSPEC_ALIGN(8) micromap;
34533         PTR32 pAllocator;
34534     } *params = args;
34535
34536     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->micromap), params->pAllocator);
34537
34538     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyMicromapEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->micromap, NULL);
34539     return STATUS_SUCCESS;
34540 }
34541
34542 #ifdef _WIN64
34543 static NTSTATUS thunk64_vkDestroyOpticalFlowSessionNV(void *args)
34544 {
34545     struct vkDestroyOpticalFlowSessionNV_params *params = args;
34546
34547     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->session), params->pAllocator);
34548
34549     wine_device_from_handle(params->device)->funcs.p_vkDestroyOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->session, NULL);
34550     return STATUS_SUCCESS;
34551 }
34552 #endif /* _WIN64 */
34553
34554 static NTSTATUS thunk32_vkDestroyOpticalFlowSessionNV(void *args)
34555 {
34556     struct
34557     {
34558         PTR32 device;
34559         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
34560         PTR32 pAllocator;
34561     } *params = args;
34562
34563     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->session), params->pAllocator);
34564
34565     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyOpticalFlowSessionNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->session, NULL);
34566     return STATUS_SUCCESS;
34567 }
34568
34569 #ifdef _WIN64
34570 static NTSTATUS thunk64_vkDestroyPipeline(void *args)
34571 {
34572     struct vkDestroyPipeline_params *params = args;
34573
34574     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->pAllocator);
34575
34576     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipeline(wine_device_from_handle(params->device)->device, params->pipeline, NULL);
34577     return STATUS_SUCCESS;
34578 }
34579 #endif /* _WIN64 */
34580
34581 static NTSTATUS thunk32_vkDestroyPipeline(void *args)
34582 {
34583     struct
34584     {
34585         PTR32 device;
34586         VkPipeline DECLSPEC_ALIGN(8) pipeline;
34587         PTR32 pAllocator;
34588     } *params = args;
34589
34590     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->pAllocator);
34591
34592     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPipeline(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipeline, NULL);
34593     return STATUS_SUCCESS;
34594 }
34595
34596 #ifdef _WIN64
34597 static NTSTATUS thunk64_vkDestroyPipelineCache(void *args)
34598 {
34599     struct vkDestroyPipelineCache_params *params = args;
34600
34601     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pAllocator);
34602
34603     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipelineCache(wine_device_from_handle(params->device)->device, params->pipelineCache, NULL);
34604     return STATUS_SUCCESS;
34605 }
34606 #endif /* _WIN64 */
34607
34608 static NTSTATUS thunk32_vkDestroyPipelineCache(void *args)
34609 {
34610     struct
34611     {
34612         PTR32 device;
34613         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
34614         PTR32 pAllocator;
34615     } *params = args;
34616
34617     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pAllocator);
34618
34619     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPipelineCache(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipelineCache, NULL);
34620     return STATUS_SUCCESS;
34621 }
34622
34623 #ifdef _WIN64
34624 static NTSTATUS thunk64_vkDestroyPipelineLayout(void *args)
34625 {
34626     struct vkDestroyPipelineLayout_params *params = args;
34627
34628     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipelineLayout), params->pAllocator);
34629
34630     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipelineLayout(wine_device_from_handle(params->device)->device, params->pipelineLayout, NULL);
34631     return STATUS_SUCCESS;
34632 }
34633 #endif /* _WIN64 */
34634
34635 static NTSTATUS thunk32_vkDestroyPipelineLayout(void *args)
34636 {
34637     struct
34638     {
34639         PTR32 device;
34640         VkPipelineLayout DECLSPEC_ALIGN(8) pipelineLayout;
34641         PTR32 pAllocator;
34642     } *params = args;
34643
34644     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineLayout), params->pAllocator);
34645
34646     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPipelineLayout(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipelineLayout, NULL);
34647     return STATUS_SUCCESS;
34648 }
34649
34650 #ifdef _WIN64
34651 static NTSTATUS thunk64_vkDestroyPrivateDataSlot(void *args)
34652 {
34653     struct vkDestroyPrivateDataSlot_params *params = args;
34654
34655     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
34656
34657     wine_device_from_handle(params->device)->funcs.p_vkDestroyPrivateDataSlot(wine_device_from_handle(params->device)->device, params->privateDataSlot, NULL);
34658     return STATUS_SUCCESS;
34659 }
34660 #endif /* _WIN64 */
34661
34662 static NTSTATUS thunk32_vkDestroyPrivateDataSlot(void *args)
34663 {
34664     struct
34665     {
34666         PTR32 device;
34667         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
34668         PTR32 pAllocator;
34669     } *params = args;
34670
34671     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
34672
34673     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPrivateDataSlot(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->privateDataSlot, NULL);
34674     return STATUS_SUCCESS;
34675 }
34676
34677 #ifdef _WIN64
34678 static NTSTATUS thunk64_vkDestroyPrivateDataSlotEXT(void *args)
34679 {
34680     struct vkDestroyPrivateDataSlotEXT_params *params = args;
34681
34682     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
34683
34684     wine_device_from_handle(params->device)->funcs.p_vkDestroyPrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->privateDataSlot, NULL);
34685     return STATUS_SUCCESS;
34686 }
34687 #endif /* _WIN64 */
34688
34689 static NTSTATUS thunk32_vkDestroyPrivateDataSlotEXT(void *args)
34690 {
34691     struct
34692     {
34693         PTR32 device;
34694         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
34695         PTR32 pAllocator;
34696     } *params = args;
34697
34698     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
34699
34700     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPrivateDataSlotEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->privateDataSlot, NULL);
34701     return STATUS_SUCCESS;
34702 }
34703
34704 #ifdef _WIN64
34705 static NTSTATUS thunk64_vkDestroyQueryPool(void *args)
34706 {
34707     struct vkDestroyQueryPool_params *params = args;
34708
34709     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->queryPool), params->pAllocator);
34710
34711     wine_device_from_handle(params->device)->funcs.p_vkDestroyQueryPool(wine_device_from_handle(params->device)->device, params->queryPool, NULL);
34712     return STATUS_SUCCESS;
34713 }
34714 #endif /* _WIN64 */
34715
34716 static NTSTATUS thunk32_vkDestroyQueryPool(void *args)
34717 {
34718     struct
34719     {
34720         PTR32 device;
34721         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
34722         PTR32 pAllocator;
34723     } *params = args;
34724
34725     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->queryPool), params->pAllocator);
34726
34727     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyQueryPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->queryPool, NULL);
34728     return STATUS_SUCCESS;
34729 }
34730
34731 #ifdef _WIN64
34732 static NTSTATUS thunk64_vkDestroyRenderPass(void *args)
34733 {
34734     struct vkDestroyRenderPass_params *params = args;
34735
34736     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pAllocator);
34737
34738     wine_device_from_handle(params->device)->funcs.p_vkDestroyRenderPass(wine_device_from_handle(params->device)->device, params->renderPass, NULL);
34739     return STATUS_SUCCESS;
34740 }
34741 #endif /* _WIN64 */
34742
34743 static NTSTATUS thunk32_vkDestroyRenderPass(void *args)
34744 {
34745     struct
34746     {
34747         PTR32 device;
34748         VkRenderPass DECLSPEC_ALIGN(8) renderPass;
34749         PTR32 pAllocator;
34750     } *params = args;
34751
34752     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pAllocator);
34753
34754     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyRenderPass(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->renderPass, NULL);
34755     return STATUS_SUCCESS;
34756 }
34757
34758 #ifdef _WIN64
34759 static NTSTATUS thunk64_vkDestroySampler(void *args)
34760 {
34761     struct vkDestroySampler_params *params = args;
34762
34763     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->sampler), params->pAllocator);
34764
34765     wine_device_from_handle(params->device)->funcs.p_vkDestroySampler(wine_device_from_handle(params->device)->device, params->sampler, NULL);
34766     return STATUS_SUCCESS;
34767 }
34768 #endif /* _WIN64 */
34769
34770 static NTSTATUS thunk32_vkDestroySampler(void *args)
34771 {
34772     struct
34773     {
34774         PTR32 device;
34775         VkSampler DECLSPEC_ALIGN(8) sampler;
34776         PTR32 pAllocator;
34777     } *params = args;
34778
34779     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->sampler), params->pAllocator);
34780
34781     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySampler(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->sampler, NULL);
34782     return STATUS_SUCCESS;
34783 }
34784
34785 #ifdef _WIN64
34786 static NTSTATUS thunk64_vkDestroySamplerYcbcrConversion(void *args)
34787 {
34788     struct vkDestroySamplerYcbcrConversion_params *params = args;
34789
34790     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
34791
34792     wine_device_from_handle(params->device)->funcs.p_vkDestroySamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->ycbcrConversion, NULL);
34793     return STATUS_SUCCESS;
34794 }
34795 #endif /* _WIN64 */
34796
34797 static NTSTATUS thunk32_vkDestroySamplerYcbcrConversion(void *args)
34798 {
34799     struct
34800     {
34801         PTR32 device;
34802         VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) ycbcrConversion;
34803         PTR32 pAllocator;
34804     } *params = args;
34805
34806     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
34807
34808     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySamplerYcbcrConversion(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->ycbcrConversion, NULL);
34809     return STATUS_SUCCESS;
34810 }
34811
34812 #ifdef _WIN64
34813 static NTSTATUS thunk64_vkDestroySamplerYcbcrConversionKHR(void *args)
34814 {
34815     struct vkDestroySamplerYcbcrConversionKHR_params *params = args;
34816
34817     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
34818
34819     wine_device_from_handle(params->device)->funcs.p_vkDestroySamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->ycbcrConversion, NULL);
34820     return STATUS_SUCCESS;
34821 }
34822 #endif /* _WIN64 */
34823
34824 static NTSTATUS thunk32_vkDestroySamplerYcbcrConversionKHR(void *args)
34825 {
34826     struct
34827     {
34828         PTR32 device;
34829         VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) ycbcrConversion;
34830         PTR32 pAllocator;
34831     } *params = args;
34832
34833     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
34834
34835     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySamplerYcbcrConversionKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->ycbcrConversion, NULL);
34836     return STATUS_SUCCESS;
34837 }
34838
34839 #ifdef _WIN64
34840 static NTSTATUS thunk64_vkDestroySemaphore(void *args)
34841 {
34842     struct vkDestroySemaphore_params *params = args;
34843
34844     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pAllocator);
34845
34846     wine_device_from_handle(params->device)->funcs.p_vkDestroySemaphore(wine_device_from_handle(params->device)->device, params->semaphore, NULL);
34847     return STATUS_SUCCESS;
34848 }
34849 #endif /* _WIN64 */
34850
34851 static NTSTATUS thunk32_vkDestroySemaphore(void *args)
34852 {
34853     struct
34854     {
34855         PTR32 device;
34856         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
34857         PTR32 pAllocator;
34858     } *params = args;
34859
34860     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pAllocator);
34861
34862     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySemaphore(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->semaphore, NULL);
34863     return STATUS_SUCCESS;
34864 }
34865
34866 #ifdef _WIN64
34867 static NTSTATUS thunk64_vkDestroyShaderEXT(void *args)
34868 {
34869     struct vkDestroyShaderEXT_params *params = args;
34870
34871     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shader), params->pAllocator);
34872
34873     wine_device_from_handle(params->device)->funcs.p_vkDestroyShaderEXT(wine_device_from_handle(params->device)->device, params->shader, NULL);
34874     return STATUS_SUCCESS;
34875 }
34876 #endif /* _WIN64 */
34877
34878 static NTSTATUS thunk32_vkDestroyShaderEXT(void *args)
34879 {
34880     struct
34881     {
34882         PTR32 device;
34883         VkShaderEXT DECLSPEC_ALIGN(8) shader;
34884         PTR32 pAllocator;
34885     } *params = args;
34886
34887     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->shader), params->pAllocator);
34888
34889     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyShaderEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->shader, NULL);
34890     return STATUS_SUCCESS;
34891 }
34892
34893 #ifdef _WIN64
34894 static NTSTATUS thunk64_vkDestroyShaderModule(void *args)
34895 {
34896     struct vkDestroyShaderModule_params *params = args;
34897
34898     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pAllocator);
34899
34900     wine_device_from_handle(params->device)->funcs.p_vkDestroyShaderModule(wine_device_from_handle(params->device)->device, params->shaderModule, NULL);
34901     return STATUS_SUCCESS;
34902 }
34903 #endif /* _WIN64 */
34904
34905 static NTSTATUS thunk32_vkDestroyShaderModule(void *args)
34906 {
34907     struct
34908     {
34909         PTR32 device;
34910         VkShaderModule DECLSPEC_ALIGN(8) shaderModule;
34911         PTR32 pAllocator;
34912     } *params = args;
34913
34914     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pAllocator);
34915
34916     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyShaderModule(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->shaderModule, NULL);
34917     return STATUS_SUCCESS;
34918 }
34919
34920 #ifdef _WIN64
34921 static NTSTATUS thunk64_vkDestroySurfaceKHR(void *args)
34922 {
34923     struct vkDestroySurfaceKHR_params *params = args;
34924
34925     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->surface), params->pAllocator);
34926
34927     wine_vkDestroySurfaceKHR(params->instance, params->surface, params->pAllocator);
34928     return STATUS_SUCCESS;
34929 }
34930 #endif /* _WIN64 */
34931
34932 static NTSTATUS thunk32_vkDestroySurfaceKHR(void *args)
34933 {
34934     struct
34935     {
34936         PTR32 instance;
34937         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
34938         PTR32 pAllocator;
34939     } *params = args;
34940
34941     TRACE("%#x, 0x%s, %#x\n", params->instance, wine_dbgstr_longlong(params->surface), params->pAllocator);
34942
34943     wine_vkDestroySurfaceKHR((VkInstance)UlongToPtr(params->instance), params->surface, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
34944     return STATUS_SUCCESS;
34945 }
34946
34947 #ifdef _WIN64
34948 static NTSTATUS thunk64_vkDestroySwapchainKHR(void *args)
34949 {
34950     struct vkDestroySwapchainKHR_params *params = args;
34951
34952     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pAllocator);
34953
34954     wine_device_from_handle(params->device)->funcs.p_vkDestroySwapchainKHR(wine_device_from_handle(params->device)->device, params->swapchain, NULL);
34955     return STATUS_SUCCESS;
34956 }
34957 #endif /* _WIN64 */
34958
34959 static NTSTATUS thunk32_vkDestroySwapchainKHR(void *args)
34960 {
34961     struct
34962     {
34963         PTR32 device;
34964         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
34965         PTR32 pAllocator;
34966     } *params = args;
34967
34968     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pAllocator);
34969
34970     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySwapchainKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->swapchain, NULL);
34971     return STATUS_SUCCESS;
34972 }
34973
34974 #ifdef _WIN64
34975 static NTSTATUS thunk64_vkDestroyValidationCacheEXT(void *args)
34976 {
34977     struct vkDestroyValidationCacheEXT_params *params = args;
34978
34979     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pAllocator);
34980
34981     wine_device_from_handle(params->device)->funcs.p_vkDestroyValidationCacheEXT(wine_device_from_handle(params->device)->device, params->validationCache, NULL);
34982     return STATUS_SUCCESS;
34983 }
34984 #endif /* _WIN64 */
34985
34986 static NTSTATUS thunk32_vkDestroyValidationCacheEXT(void *args)
34987 {
34988     struct
34989     {
34990         PTR32 device;
34991         VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
34992         PTR32 pAllocator;
34993     } *params = args;
34994
34995     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pAllocator);
34996
34997     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyValidationCacheEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->validationCache, NULL);
34998     return STATUS_SUCCESS;
34999 }
35000
35001 #ifdef _WIN64
35002 static NTSTATUS thunk64_vkDeviceWaitIdle(void *args)
35003 {
35004     struct vkDeviceWaitIdle_params *params = args;
35005
35006     TRACE("%p\n", params->device);
35007
35008     params->result = wine_device_from_handle(params->device)->funcs.p_vkDeviceWaitIdle(wine_device_from_handle(params->device)->device);
35009     return STATUS_SUCCESS;
35010 }
35011 #endif /* _WIN64 */
35012
35013 static NTSTATUS thunk32_vkDeviceWaitIdle(void *args)
35014 {
35015     struct
35016     {
35017         PTR32 device;
35018         VkResult result;
35019     } *params = args;
35020
35021     TRACE("%#x\n", params->device);
35022
35023     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDeviceWaitIdle(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device);
35024     return STATUS_SUCCESS;
35025 }
35026
35027 #ifdef _WIN64
35028 static NTSTATUS thunk64_vkEndCommandBuffer(void *args)
35029 {
35030     struct vkEndCommandBuffer_params *params = args;
35031
35032     TRACE("%p\n", params->commandBuffer);
35033
35034     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkEndCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
35035     return STATUS_SUCCESS;
35036 }
35037 #endif /* _WIN64 */
35038
35039 static NTSTATUS thunk32_vkEndCommandBuffer(void *args)
35040 {
35041     struct
35042     {
35043         PTR32 commandBuffer;
35044         VkResult result;
35045     } *params = args;
35046
35047     TRACE("%#x\n", params->commandBuffer);
35048
35049     params->result = wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkEndCommandBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
35050     return STATUS_SUCCESS;
35051 }
35052
35053 #ifdef _WIN64
35054 static NTSTATUS thunk64_vkEnumerateDeviceExtensionProperties(void *args)
35055 {
35056     struct vkEnumerateDeviceExtensionProperties_params *params = args;
35057
35058     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
35059
35060     params->result = wine_vkEnumerateDeviceExtensionProperties(params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
35061     return STATUS_SUCCESS;
35062 }
35063 #endif /* _WIN64 */
35064
35065 static NTSTATUS thunk32_vkEnumerateDeviceExtensionProperties(void *args)
35066 {
35067     struct
35068     {
35069         PTR32 physicalDevice;
35070         PTR32 pLayerName;
35071         PTR32 pPropertyCount;
35072         PTR32 pProperties;
35073         VkResult result;
35074     } *params = args;
35075
35076     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
35077
35078     params->result = wine_vkEnumerateDeviceExtensionProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), (const char *)UlongToPtr(params->pLayerName), (uint32_t *)UlongToPtr(params->pPropertyCount), (VkExtensionProperties *)UlongToPtr(params->pProperties));
35079     return STATUS_SUCCESS;
35080 }
35081
35082 #ifdef _WIN64
35083 static NTSTATUS thunk64_vkEnumerateDeviceLayerProperties(void *args)
35084 {
35085     struct vkEnumerateDeviceLayerProperties_params *params = args;
35086
35087     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
35088
35089     params->result = wine_vkEnumerateDeviceLayerProperties(params->physicalDevice, params->pPropertyCount, params->pProperties);
35090     return STATUS_SUCCESS;
35091 }
35092 #endif /* _WIN64 */
35093
35094 static NTSTATUS thunk32_vkEnumerateDeviceLayerProperties(void *args)
35095 {
35096     struct
35097     {
35098         PTR32 physicalDevice;
35099         PTR32 pPropertyCount;
35100         PTR32 pProperties;
35101         VkResult result;
35102     } *params = args;
35103
35104     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
35105
35106     params->result = wine_vkEnumerateDeviceLayerProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), (uint32_t *)UlongToPtr(params->pPropertyCount), (VkLayerProperties *)UlongToPtr(params->pProperties));
35107     return STATUS_SUCCESS;
35108 }
35109
35110 #ifdef _WIN64
35111 static NTSTATUS thunk64_vkEnumerateInstanceExtensionProperties(void *args)
35112 {
35113     struct vkEnumerateInstanceExtensionProperties_params *params = args;
35114
35115     TRACE("%p, %p, %p\n", params->pLayerName, params->pPropertyCount, params->pProperties);
35116
35117     params->result = wine_vkEnumerateInstanceExtensionProperties(params->pLayerName, params->pPropertyCount, params->pProperties);
35118     return STATUS_SUCCESS;
35119 }
35120 #endif /* _WIN64 */
35121
35122 static NTSTATUS thunk32_vkEnumerateInstanceExtensionProperties(void *args)
35123 {
35124     struct
35125     {
35126         PTR32 pLayerName;
35127         PTR32 pPropertyCount;
35128         PTR32 pProperties;
35129         VkResult result;
35130     } *params = args;
35131
35132     TRACE("%#x, %#x, %#x\n", params->pLayerName, params->pPropertyCount, params->pProperties);
35133
35134     params->result = wine_vkEnumerateInstanceExtensionProperties((const char *)UlongToPtr(params->pLayerName), (uint32_t *)UlongToPtr(params->pPropertyCount), (VkExtensionProperties *)UlongToPtr(params->pProperties));
35135     return STATUS_SUCCESS;
35136 }
35137
35138 #ifdef _WIN64
35139 static NTSTATUS thunk64_vkEnumerateInstanceVersion(void *args)
35140 {
35141     struct vkEnumerateInstanceVersion_params *params = args;
35142
35143     TRACE("%p\n", params->pApiVersion);
35144
35145     params->result = wine_vkEnumerateInstanceVersion(params->pApiVersion);
35146     return STATUS_SUCCESS;
35147 }
35148 #endif /* _WIN64 */
35149
35150 static NTSTATUS thunk32_vkEnumerateInstanceVersion(void *args)
35151 {
35152     struct
35153     {
35154         PTR32 pApiVersion;
35155         VkResult result;
35156     } *params = args;
35157
35158     TRACE("%#x\n", params->pApiVersion);
35159
35160     params->result = wine_vkEnumerateInstanceVersion((uint32_t *)UlongToPtr(params->pApiVersion));
35161     return STATUS_SUCCESS;
35162 }
35163
35164 #ifdef _WIN64
35165 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceGroups(void *args)
35166 {
35167     struct vkEnumeratePhysicalDeviceGroups_params *params = args;
35168
35169     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
35170
35171     params->result = wine_vkEnumeratePhysicalDeviceGroups(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
35172     return STATUS_SUCCESS;
35173 }
35174 #endif /* _WIN64 */
35175
35176 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceGroups(void *args)
35177 {
35178     struct
35179     {
35180         PTR32 instance;
35181         PTR32 pPhysicalDeviceGroupCount;
35182         PTR32 pPhysicalDeviceGroupProperties;
35183         VkResult result;
35184     } *params = args;
35185     VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties_host;
35186     struct conversion_context ctx;
35187
35188     TRACE("%#x, %#x, %#x\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
35189
35190     init_conversion_context(&ctx);
35191     pPhysicalDeviceGroupProperties_host = convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(&ctx, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
35192     params->result = wine_vkEnumeratePhysicalDeviceGroups((VkInstance)UlongToPtr(params->instance), (uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount), pPhysicalDeviceGroupProperties_host);
35193     convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(pPhysicalDeviceGroupProperties_host, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
35194     free_conversion_context(&ctx);
35195     return STATUS_SUCCESS;
35196 }
35197
35198 #ifdef _WIN64
35199 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceGroupsKHR(void *args)
35200 {
35201     struct vkEnumeratePhysicalDeviceGroupsKHR_params *params = args;
35202
35203     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
35204
35205     params->result = wine_vkEnumeratePhysicalDeviceGroupsKHR(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
35206     return STATUS_SUCCESS;
35207 }
35208 #endif /* _WIN64 */
35209
35210 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceGroupsKHR(void *args)
35211 {
35212     struct
35213     {
35214         PTR32 instance;
35215         PTR32 pPhysicalDeviceGroupCount;
35216         PTR32 pPhysicalDeviceGroupProperties;
35217         VkResult result;
35218     } *params = args;
35219     VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties_host;
35220     struct conversion_context ctx;
35221
35222     TRACE("%#x, %#x, %#x\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
35223
35224     init_conversion_context(&ctx);
35225     pPhysicalDeviceGroupProperties_host = convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(&ctx, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
35226     params->result = wine_vkEnumeratePhysicalDeviceGroupsKHR((VkInstance)UlongToPtr(params->instance), (uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount), pPhysicalDeviceGroupProperties_host);
35227     convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(pPhysicalDeviceGroupProperties_host, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
35228     free_conversion_context(&ctx);
35229     return STATUS_SUCCESS;
35230 }
35231
35232 #ifdef _WIN64
35233 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(void *args)
35234 {
35235     struct vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_params *params = args;
35236
35237     TRACE("%p, %u, %p, %p, %p\n", params->physicalDevice, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);
35238
35239     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);
35240     return STATUS_SUCCESS;
35241 }
35242 #endif /* _WIN64 */
35243
35244 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(void *args)
35245 {
35246     struct
35247     {
35248         PTR32 physicalDevice;
35249         uint32_t queueFamilyIndex;
35250         PTR32 pCounterCount;
35251         PTR32 pCounters;
35252         PTR32 pCounterDescriptions;
35253         VkResult result;
35254     } *params = args;
35255     VkPerformanceCounterKHR *pCounters_host;
35256     VkPerformanceCounterDescriptionKHR *pCounterDescriptions_host;
35257     struct conversion_context ctx;
35258
35259     TRACE("%#x, %u, %#x, %#x, %#x\n", params->physicalDevice, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);
35260
35261     init_conversion_context(&ctx);
35262     pCounters_host = convert_VkPerformanceCounterKHR_array_win32_to_host(&ctx, (VkPerformanceCounterKHR32 *)UlongToPtr(params->pCounters), *(uint32_t *)UlongToPtr(params->pCounterCount));
35263     pCounterDescriptions_host = convert_VkPerformanceCounterDescriptionKHR_array_win32_to_host(&ctx, (VkPerformanceCounterDescriptionKHR32 *)UlongToPtr(params->pCounterDescriptions), *(uint32_t *)UlongToPtr(params->pCounterCount));
35264     params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->queueFamilyIndex, (uint32_t *)UlongToPtr(params->pCounterCount), pCounters_host, pCounterDescriptions_host);
35265     convert_VkPerformanceCounterKHR_array_host_to_win32(pCounters_host, (VkPerformanceCounterKHR32 *)UlongToPtr(params->pCounters), *(uint32_t *)UlongToPtr(params->pCounterCount));
35266     convert_VkPerformanceCounterDescriptionKHR_array_host_to_win32(pCounterDescriptions_host, (VkPerformanceCounterDescriptionKHR32 *)UlongToPtr(params->pCounterDescriptions), *(uint32_t *)UlongToPtr(params->pCounterCount));
35267     free_conversion_context(&ctx);
35268     return STATUS_SUCCESS;
35269 }
35270
35271 #ifdef _WIN64
35272 static NTSTATUS thunk64_vkEnumeratePhysicalDevices(void *args)
35273 {
35274     struct vkEnumeratePhysicalDevices_params *params = args;
35275
35276     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
35277
35278     params->result = wine_vkEnumeratePhysicalDevices(params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
35279     return STATUS_SUCCESS;
35280 }
35281 #endif /* _WIN64 */
35282
35283 static NTSTATUS thunk32_vkEnumeratePhysicalDevices(void *args)
35284 {
35285     struct
35286     {
35287         PTR32 instance;
35288         PTR32 pPhysicalDeviceCount;
35289         PTR32 pPhysicalDevices;
35290         VkResult result;
35291     } *params = args;
35292     VkPhysicalDevice *pPhysicalDevices_host;
35293     struct conversion_context ctx;
35294
35295     TRACE("%#x, %#x, %#x\n", params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
35296
35297     init_conversion_context(&ctx);
35298     pPhysicalDevices_host = (params->pPhysicalDevices && *(uint32_t *)UlongToPtr(params->pPhysicalDeviceCount)) ? conversion_context_alloc(&ctx, sizeof(*pPhysicalDevices_host) * *(uint32_t *)UlongToPtr(params->pPhysicalDeviceCount)) : NULL;
35299     params->result = wine_vkEnumeratePhysicalDevices((VkInstance)UlongToPtr(params->instance), (uint32_t *)UlongToPtr(params->pPhysicalDeviceCount), pPhysicalDevices_host);
35300     convert_VkPhysicalDevice_array_unwrapped_host_to_win32(pPhysicalDevices_host, (PTR32 *)UlongToPtr(params->pPhysicalDevices), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceCount));
35301     free_conversion_context(&ctx);
35302     return STATUS_SUCCESS;
35303 }
35304
35305 #ifdef _WIN64
35306 static NTSTATUS thunk64_vkFlushMappedMemoryRanges(void *args)
35307 {
35308     struct vkFlushMappedMemoryRanges_params *params = args;
35309     const VkMappedMemoryRange *pMemoryRanges_host;
35310     struct conversion_context ctx;
35311
35312     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
35313
35314     init_conversion_context(&ctx);
35315     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win64_to_host(&ctx, params->pMemoryRanges, params->memoryRangeCount);
35316     params->result = wine_device_from_handle(params->device)->funcs.p_vkFlushMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, pMemoryRanges_host);
35317     free_conversion_context(&ctx);
35318     return STATUS_SUCCESS;
35319 }
35320 #endif /* _WIN64 */
35321
35322 static NTSTATUS thunk32_vkFlushMappedMemoryRanges(void *args)
35323 {
35324     struct
35325     {
35326         PTR32 device;
35327         uint32_t memoryRangeCount;
35328         PTR32 pMemoryRanges;
35329         VkResult result;
35330     } *params = args;
35331     const VkMappedMemoryRange *pMemoryRanges_host;
35332     struct conversion_context ctx;
35333
35334     TRACE("%#x, %u, %#x\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
35335
35336     init_conversion_context(&ctx);
35337     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win32_to_host(&ctx, (const VkMappedMemoryRange32 *)UlongToPtr(params->pMemoryRanges), params->memoryRangeCount);
35338     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkFlushMappedMemoryRanges(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->memoryRangeCount, pMemoryRanges_host);
35339     free_conversion_context(&ctx);
35340     return STATUS_SUCCESS;
35341 }
35342
35343 #ifdef _WIN64
35344 static NTSTATUS thunk64_vkFreeCommandBuffers(void *args)
35345 {
35346     struct vkFreeCommandBuffers_params *params = args;
35347
35348     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->commandPool), params->commandBufferCount, params->pCommandBuffers);
35349
35350     wine_vkFreeCommandBuffers(params->device, params->commandPool, params->commandBufferCount, params->pCommandBuffers);
35351     return STATUS_SUCCESS;
35352 }
35353 #endif /* _WIN64 */
35354
35355 static NTSTATUS thunk32_vkFreeCommandBuffers(void *args)
35356 {
35357     struct
35358     {
35359         PTR32 device;
35360         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
35361         uint32_t commandBufferCount;
35362         PTR32 pCommandBuffers;
35363     } *params = args;
35364     const VkCommandBuffer *pCommandBuffers_host;
35365     struct conversion_context ctx;
35366
35367     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->commandBufferCount, params->pCommandBuffers);
35368
35369     init_conversion_context(&ctx);
35370     pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_unwrapped_host(&ctx, (const PTR32 *)UlongToPtr(params->pCommandBuffers), params->commandBufferCount);
35371     wine_vkFreeCommandBuffers((VkDevice)UlongToPtr(params->device), params->commandPool, params->commandBufferCount, pCommandBuffers_host);
35372     free_conversion_context(&ctx);
35373     return STATUS_SUCCESS;
35374 }
35375
35376 #ifdef _WIN64
35377 static NTSTATUS thunk64_vkFreeDescriptorSets(void *args)
35378 {
35379     struct vkFreeDescriptorSets_params *params = args;
35380
35381     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->descriptorSetCount, params->pDescriptorSets);
35382
35383     params->result = wine_device_from_handle(params->device)->funcs.p_vkFreeDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorPool, params->descriptorSetCount, params->pDescriptorSets);
35384     return STATUS_SUCCESS;
35385 }
35386 #endif /* _WIN64 */
35387
35388 static NTSTATUS thunk32_vkFreeDescriptorSets(void *args)
35389 {
35390     struct
35391     {
35392         PTR32 device;
35393         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
35394         uint32_t descriptorSetCount;
35395         PTR32 pDescriptorSets;
35396         VkResult result;
35397     } *params = args;
35398
35399     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->descriptorSetCount, params->pDescriptorSets);
35400
35401     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkFreeDescriptorSets(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorPool, params->descriptorSetCount, (const VkDescriptorSet *)UlongToPtr(params->pDescriptorSets));
35402     return STATUS_SUCCESS;
35403 }
35404
35405 #ifdef _WIN64
35406 static NTSTATUS thunk64_vkFreeMemory(void *args)
35407 {
35408     struct vkFreeMemory_params *params = args;
35409
35410     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->memory), params->pAllocator);
35411
35412     wine_vkFreeMemory(params->device, params->memory, params->pAllocator);
35413     return STATUS_SUCCESS;
35414 }
35415 #endif /* _WIN64 */
35416
35417 static NTSTATUS thunk32_vkFreeMemory(void *args)
35418 {
35419     struct
35420     {
35421         PTR32 device;
35422         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
35423         PTR32 pAllocator;
35424     } *params = args;
35425
35426     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->memory), params->pAllocator);
35427
35428     wine_vkFreeMemory((VkDevice)UlongToPtr(params->device), params->memory, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
35429     return STATUS_SUCCESS;
35430 }
35431
35432 #ifdef _WIN64
35433 static NTSTATUS thunk64_vkGetAccelerationStructureBuildSizesKHR(void *args)
35434 {
35435     struct vkGetAccelerationStructureBuildSizesKHR_params *params = args;
35436
35437     TRACE("%p, %#x, %p, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);
35438
35439     wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureBuildSizesKHR(wine_device_from_handle(params->device)->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);
35440     return STATUS_SUCCESS;
35441 }
35442 #endif /* _WIN64 */
35443
35444 static NTSTATUS thunk32_vkGetAccelerationStructureBuildSizesKHR(void *args)
35445 {
35446     struct
35447     {
35448         PTR32 device;
35449         VkAccelerationStructureBuildTypeKHR buildType;
35450         PTR32 pBuildInfo;
35451         PTR32 pMaxPrimitiveCounts;
35452         PTR32 pSizeInfo;
35453     } *params = args;
35454     VkAccelerationStructureBuildGeometryInfoKHR pBuildInfo_host;
35455     VkAccelerationStructureBuildSizesInfoKHR pSizeInfo_host;
35456     struct conversion_context ctx;
35457
35458     TRACE("%#x, %#x, %#x, %#x, %#x\n", params->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);
35459
35460     init_conversion_context(&ctx);
35461     convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(&ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pBuildInfo), &pBuildInfo_host);
35462     convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_host((VkAccelerationStructureBuildSizesInfoKHR32 *)UlongToPtr(params->pSizeInfo), &pSizeInfo_host);
35463     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetAccelerationStructureBuildSizesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->buildType, &pBuildInfo_host, (const uint32_t *)UlongToPtr(params->pMaxPrimitiveCounts), &pSizeInfo_host);
35464     convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win32(&pSizeInfo_host, (VkAccelerationStructureBuildSizesInfoKHR32 *)UlongToPtr(params->pSizeInfo));
35465     free_conversion_context(&ctx);
35466     return STATUS_SUCCESS;
35467 }
35468
35469 #ifdef _WIN64
35470 static NTSTATUS thunk64_vkGetAccelerationStructureDeviceAddressKHR(void *args)
35471 {
35472     struct vkGetAccelerationStructureDeviceAddressKHR_params *params = args;
35473
35474     TRACE("%p, %p\n", params->device, params->pInfo);
35475
35476     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureDeviceAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
35477     return STATUS_SUCCESS;
35478 }
35479 #endif /* _WIN64 */
35480
35481 static NTSTATUS thunk32_vkGetAccelerationStructureDeviceAddressKHR(void *args)
35482 {
35483     struct
35484     {
35485         PTR32 device;
35486         PTR32 pInfo;
35487         VkDeviceAddress result;
35488     } *params = args;
35489     VkAccelerationStructureDeviceAddressInfoKHR pInfo_host;
35490
35491     TRACE("%#x, %#x\n", params->device, params->pInfo);
35492
35493     convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_host((const VkAccelerationStructureDeviceAddressInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
35494     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetAccelerationStructureDeviceAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
35495     return STATUS_SUCCESS;
35496 }
35497
35498 #ifdef _WIN64
35499 static NTSTATUS thunk64_vkGetAccelerationStructureHandleNV(void *args)
35500 {
35501     struct vkGetAccelerationStructureHandleNV_params *params = args;
35502
35503     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), wine_dbgstr_longlong(params->dataSize), params->pData);
35504
35505     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureHandleNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, params->dataSize, params->pData);
35506     return STATUS_SUCCESS;
35507 }
35508 #endif /* _WIN64 */
35509
35510 static NTSTATUS thunk32_vkGetAccelerationStructureHandleNV(void *args)
35511 {
35512     struct
35513     {
35514         PTR32 device;
35515         VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
35516         PTR32 dataSize;
35517         PTR32 pData;
35518         VkResult result;
35519     } *params = args;
35520
35521     TRACE("%#x, 0x%s, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), wine_dbgstr_longlong(params->dataSize), params->pData);
35522
35523     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetAccelerationStructureHandleNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->accelerationStructure, params->dataSize, (void *)UlongToPtr(params->pData));
35524     return STATUS_SUCCESS;
35525 }
35526
35527 #ifdef _WIN64
35528 static NTSTATUS thunk64_vkGetAccelerationStructureMemoryRequirementsNV(void *args)
35529 {
35530     struct vkGetAccelerationStructureMemoryRequirementsNV_params *params = args;
35531
35532     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
35533
35534     wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
35535     return STATUS_SUCCESS;
35536 }
35537 #endif /* _WIN64 */
35538
35539 static NTSTATUS thunk32_vkGetAccelerationStructureMemoryRequirementsNV(void *args)
35540 {
35541     struct
35542     {
35543         PTR32 device;
35544         PTR32 pInfo;
35545         PTR32 pMemoryRequirements;
35546     } *params = args;
35547     VkAccelerationStructureMemoryRequirementsInfoNV pInfo_host;
35548     VkMemoryRequirements2KHR pMemoryRequirements_host;
35549
35550     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
35551
35552     convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32_to_host((const VkAccelerationStructureMemoryRequirementsInfoNV32 *)UlongToPtr(params->pInfo), &pInfo_host);
35553     convert_VkMemoryRequirements2KHR_win32_to_host((VkMemoryRequirements2KHR32 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
35554     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
35555     convert_VkMemoryRequirements2KHR_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements2KHR32 *)UlongToPtr(params->pMemoryRequirements));
35556     return STATUS_SUCCESS;
35557 }
35558
35559 #ifdef _WIN64
35560 static NTSTATUS thunk64_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(void *args)
35561 {
35562     struct vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_params *params = args;
35563
35564     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
35565
35566     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
35567     return STATUS_SUCCESS;
35568 }
35569 #endif /* _WIN64 */
35570
35571 static NTSTATUS thunk32_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(void *args)
35572 {
35573     struct
35574     {
35575         PTR32 device;
35576         PTR32 pInfo;
35577         PTR32 pData;
35578         VkResult result;
35579     } *params = args;
35580     VkAccelerationStructureCaptureDescriptorDataInfoEXT pInfo_host;
35581
35582     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
35583
35584     convert_VkAccelerationStructureCaptureDescriptorDataInfoEXT_win32_to_host((const VkAccelerationStructureCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
35585     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, (void *)UlongToPtr(params->pData));
35586     return STATUS_SUCCESS;
35587 }
35588
35589 #ifdef _WIN64
35590 static NTSTATUS thunk64_vkGetBufferDeviceAddress(void *args)
35591 {
35592     struct vkGetBufferDeviceAddress_params *params = args;
35593
35594     TRACE("%p, %p\n", params->device, params->pInfo);
35595
35596     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddress(wine_device_from_handle(params->device)->device, params->pInfo);
35597     return STATUS_SUCCESS;
35598 }
35599 #endif /* _WIN64 */
35600
35601 static NTSTATUS thunk32_vkGetBufferDeviceAddress(void *args)
35602 {
35603     struct
35604     {
35605         PTR32 device;
35606         PTR32 pInfo;
35607         VkDeviceAddress result;
35608     } *params = args;
35609     VkBufferDeviceAddressInfo pInfo_host;
35610
35611     TRACE("%#x, %#x\n", params->device, params->pInfo);
35612
35613     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
35614     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferDeviceAddress(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
35615     return STATUS_SUCCESS;
35616 }
35617
35618 #ifdef _WIN64
35619 static NTSTATUS thunk64_vkGetBufferDeviceAddressEXT(void *args)
35620 {
35621     struct vkGetBufferDeviceAddressEXT_params *params = args;
35622
35623     TRACE("%p, %p\n", params->device, params->pInfo);
35624
35625     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddressEXT(wine_device_from_handle(params->device)->device, params->pInfo);
35626     return STATUS_SUCCESS;
35627 }
35628 #endif /* _WIN64 */
35629
35630 static NTSTATUS thunk32_vkGetBufferDeviceAddressEXT(void *args)
35631 {
35632     struct
35633     {
35634         PTR32 device;
35635         PTR32 pInfo;
35636         VkDeviceAddress result;
35637     } *params = args;
35638     VkBufferDeviceAddressInfo pInfo_host;
35639
35640     TRACE("%#x, %#x\n", params->device, params->pInfo);
35641
35642     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
35643     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferDeviceAddressEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
35644     return STATUS_SUCCESS;
35645 }
35646
35647 #ifdef _WIN64
35648 static NTSTATUS thunk64_vkGetBufferDeviceAddressKHR(void *args)
35649 {
35650     struct vkGetBufferDeviceAddressKHR_params *params = args;
35651
35652     TRACE("%p, %p\n", params->device, params->pInfo);
35653
35654     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
35655     return STATUS_SUCCESS;
35656 }
35657 #endif /* _WIN64 */
35658
35659 static NTSTATUS thunk32_vkGetBufferDeviceAddressKHR(void *args)
35660 {
35661     struct
35662     {
35663         PTR32 device;
35664         PTR32 pInfo;
35665         VkDeviceAddress result;
35666     } *params = args;
35667     VkBufferDeviceAddressInfo pInfo_host;
35668
35669     TRACE("%#x, %#x\n", params->device, params->pInfo);
35670
35671     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
35672     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferDeviceAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
35673     return STATUS_SUCCESS;
35674 }
35675
35676 #ifdef _WIN64
35677 static NTSTATUS thunk64_vkGetBufferMemoryRequirements(void *args)
35678 {
35679     struct vkGetBufferMemoryRequirements_params *params = args;
35680
35681     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->buffer), params->pMemoryRequirements);
35682
35683     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements(wine_device_from_handle(params->device)->device, params->buffer, params->pMemoryRequirements);
35684     return STATUS_SUCCESS;
35685 }
35686 #endif /* _WIN64 */
35687
35688 static NTSTATUS thunk32_vkGetBufferMemoryRequirements(void *args)
35689 {
35690     struct
35691     {
35692         PTR32 device;
35693         VkBuffer DECLSPEC_ALIGN(8) buffer;
35694         PTR32 pMemoryRequirements;
35695     } *params = args;
35696     VkMemoryRequirements pMemoryRequirements_host;
35697
35698     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->buffer), params->pMemoryRequirements);
35699
35700     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->buffer, &pMemoryRequirements_host);
35701     convert_VkMemoryRequirements_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements32 *)UlongToPtr(params->pMemoryRequirements));
35702     return STATUS_SUCCESS;
35703 }
35704
35705 #ifdef _WIN64
35706 static NTSTATUS thunk64_vkGetBufferMemoryRequirements2(void *args)
35707 {
35708     struct vkGetBufferMemoryRequirements2_params *params = args;
35709
35710     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
35711
35712     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements2(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
35713     return STATUS_SUCCESS;
35714 }
35715 #endif /* _WIN64 */
35716
35717 static NTSTATUS thunk32_vkGetBufferMemoryRequirements2(void *args)
35718 {
35719     struct
35720     {
35721         PTR32 device;
35722         PTR32 pInfo;
35723         PTR32 pMemoryRequirements;
35724     } *params = args;
35725     VkBufferMemoryRequirementsInfo2 pInfo_host;
35726     VkMemoryRequirements2 pMemoryRequirements_host;
35727     struct conversion_context ctx;
35728
35729     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
35730
35731     init_conversion_context(&ctx);
35732     convert_VkBufferMemoryRequirementsInfo2_win32_to_host((const VkBufferMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
35733     convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
35734     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferMemoryRequirements2(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
35735     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
35736     free_conversion_context(&ctx);
35737     return STATUS_SUCCESS;
35738 }
35739
35740 #ifdef _WIN64
35741 static NTSTATUS thunk64_vkGetBufferMemoryRequirements2KHR(void *args)
35742 {
35743     struct vkGetBufferMemoryRequirements2KHR_params *params = args;
35744
35745     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
35746
35747     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
35748     return STATUS_SUCCESS;
35749 }
35750 #endif /* _WIN64 */
35751
35752 static NTSTATUS thunk32_vkGetBufferMemoryRequirements2KHR(void *args)
35753 {
35754     struct
35755     {
35756         PTR32 device;
35757         PTR32 pInfo;
35758         PTR32 pMemoryRequirements;
35759     } *params = args;
35760     VkBufferMemoryRequirementsInfo2 pInfo_host;
35761     VkMemoryRequirements2 pMemoryRequirements_host;
35762     struct conversion_context ctx;
35763
35764     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
35765
35766     init_conversion_context(&ctx);
35767     convert_VkBufferMemoryRequirementsInfo2_win32_to_host((const VkBufferMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
35768     convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
35769     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferMemoryRequirements2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
35770     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
35771     free_conversion_context(&ctx);
35772     return STATUS_SUCCESS;
35773 }
35774
35775 #ifdef _WIN64
35776 static NTSTATUS thunk64_vkGetBufferOpaqueCaptureAddress(void *args)
35777 {
35778     struct vkGetBufferOpaqueCaptureAddress_params *params = args;
35779
35780     TRACE("%p, %p\n", params->device, params->pInfo);
35781
35782     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureAddress(wine_device_from_handle(params->device)->device, params->pInfo);
35783     return STATUS_SUCCESS;
35784 }
35785 #endif /* _WIN64 */
35786
35787 static NTSTATUS thunk32_vkGetBufferOpaqueCaptureAddress(void *args)
35788 {
35789     struct
35790     {
35791         PTR32 device;
35792         PTR32 pInfo;
35793         uint64_t result;
35794     } *params = args;
35795     VkBufferDeviceAddressInfo pInfo_host;
35796
35797     TRACE("%#x, %#x\n", params->device, params->pInfo);
35798
35799     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
35800     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferOpaqueCaptureAddress(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
35801     return STATUS_SUCCESS;
35802 }
35803
35804 #ifdef _WIN64
35805 static NTSTATUS thunk64_vkGetBufferOpaqueCaptureAddressKHR(void *args)
35806 {
35807     struct vkGetBufferOpaqueCaptureAddressKHR_params *params = args;
35808
35809     TRACE("%p, %p\n", params->device, params->pInfo);
35810
35811     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
35812     return STATUS_SUCCESS;
35813 }
35814 #endif /* _WIN64 */
35815
35816 static NTSTATUS thunk32_vkGetBufferOpaqueCaptureAddressKHR(void *args)
35817 {
35818     struct
35819     {
35820         PTR32 device;
35821         PTR32 pInfo;
35822         uint64_t result;
35823     } *params = args;
35824     VkBufferDeviceAddressInfo pInfo_host;
35825
35826     TRACE("%#x, %#x\n", params->device, params->pInfo);
35827
35828     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
35829     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferOpaqueCaptureAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
35830     return STATUS_SUCCESS;
35831 }
35832
35833 #ifdef _WIN64
35834 static NTSTATUS thunk64_vkGetBufferOpaqueCaptureDescriptorDataEXT(void *args)
35835 {
35836     struct vkGetBufferOpaqueCaptureDescriptorDataEXT_params *params = args;
35837
35838     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
35839
35840     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
35841     return STATUS_SUCCESS;
35842 }
35843 #endif /* _WIN64 */
35844
35845 static NTSTATUS thunk32_vkGetBufferOpaqueCaptureDescriptorDataEXT(void *args)
35846 {
35847     struct
35848     {
35849         PTR32 device;
35850         PTR32 pInfo;
35851         PTR32 pData;
35852         VkResult result;
35853     } *params = args;
35854     VkBufferCaptureDescriptorDataInfoEXT pInfo_host;
35855
35856     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
35857
35858     convert_VkBufferCaptureDescriptorDataInfoEXT_win32_to_host((const VkBufferCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
35859     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferOpaqueCaptureDescriptorDataEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, (void *)UlongToPtr(params->pData));
35860     return STATUS_SUCCESS;
35861 }
35862
35863 #ifdef _WIN64
35864 static NTSTATUS thunk64_vkGetCalibratedTimestampsEXT(void *args)
35865 {
35866     struct vkGetCalibratedTimestampsEXT_params *params = args;
35867
35868     TRACE("%p, %u, %p, %p, %p\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
35869
35870     params->result = wine_vkGetCalibratedTimestampsEXT(params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
35871     return STATUS_SUCCESS;
35872 }
35873 #endif /* _WIN64 */
35874
35875 static NTSTATUS thunk32_vkGetCalibratedTimestampsEXT(void *args)
35876 {
35877     struct
35878     {
35879         PTR32 device;
35880         uint32_t timestampCount;
35881         PTR32 pTimestampInfos;
35882         PTR32 pTimestamps;
35883         PTR32 pMaxDeviation;
35884         VkResult result;
35885     } *params = args;
35886     const VkCalibratedTimestampInfoEXT *pTimestampInfos_host;
35887     struct conversion_context ctx;
35888
35889     TRACE("%#x, %u, %#x, %#x, %#x\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
35890
35891     init_conversion_context(&ctx);
35892     pTimestampInfos_host = convert_VkCalibratedTimestampInfoEXT_array_win32_to_host(&ctx, (const VkCalibratedTimestampInfoEXT32 *)UlongToPtr(params->pTimestampInfos), params->timestampCount);
35893     params->result = wine_vkGetCalibratedTimestampsEXT((VkDevice)UlongToPtr(params->device), params->timestampCount, pTimestampInfos_host, (uint64_t *)UlongToPtr(params->pTimestamps), (uint64_t *)UlongToPtr(params->pMaxDeviation));
35894     free_conversion_context(&ctx);
35895     return STATUS_SUCCESS;
35896 }
35897
35898 #ifdef _WIN64
35899 static NTSTATUS thunk64_vkGetDeferredOperationMaxConcurrencyKHR(void *args)
35900 {
35901     struct vkGetDeferredOperationMaxConcurrencyKHR_params *params = args;
35902
35903     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
35904
35905     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationMaxConcurrencyKHR(wine_device_from_handle(params->device)->device, params->operation);
35906     return STATUS_SUCCESS;
35907 }
35908 #endif /* _WIN64 */
35909
35910 static NTSTATUS thunk32_vkGetDeferredOperationMaxConcurrencyKHR(void *args)
35911 {
35912     struct
35913     {
35914         PTR32 device;
35915         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
35916         uint32_t result;
35917     } *params = args;
35918
35919     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
35920
35921     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeferredOperationMaxConcurrencyKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->operation);
35922     return STATUS_SUCCESS;
35923 }
35924
35925 #ifdef _WIN64
35926 static NTSTATUS thunk64_vkGetDeferredOperationResultKHR(void *args)
35927 {
35928     struct vkGetDeferredOperationResultKHR_params *params = args;
35929
35930     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
35931
35932     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationResultKHR(wine_device_from_handle(params->device)->device, params->operation);
35933     return STATUS_SUCCESS;
35934 }
35935 #endif /* _WIN64 */
35936
35937 static NTSTATUS thunk32_vkGetDeferredOperationResultKHR(void *args)
35938 {
35939     struct
35940     {
35941         PTR32 device;
35942         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
35943         VkResult result;
35944     } *params = args;
35945
35946     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
35947
35948     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeferredOperationResultKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->operation);
35949     return STATUS_SUCCESS;
35950 }
35951
35952 #ifdef _WIN64
35953 static void thunk64_vkGetDescriptorEXT(void *args)
35954 {
35955     struct vkGetDescriptorEXT_params *params = args;
35956
35957     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorEXT(wine_device_from_handle(params->device)->device, params->pDescriptorInfo, params->dataSize, params->pDescriptor);
35958 }
35959 #endif /* _WIN64 */
35960
35961 static void thunk32_vkGetDescriptorEXT(void *args)
35962 {
35963     struct
35964     {
35965         PTR32 device;
35966         PTR32 pDescriptorInfo;
35967         PTR32 dataSize;
35968         PTR32 pDescriptor;
35969     } *params = args;
35970     VkDescriptorGetInfoEXT pDescriptorInfo_host;
35971     struct conversion_context ctx;
35972
35973     init_conversion_context(&ctx);
35974     convert_VkDescriptorGetInfoEXT_win32_to_host(&ctx, (const VkDescriptorGetInfoEXT32 *)UlongToPtr(params->pDescriptorInfo), &pDescriptorInfo_host);
35975     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pDescriptorInfo_host, params->dataSize, (void *)UlongToPtr(params->pDescriptor));
35976     free_conversion_context(&ctx);
35977 }
35978
35979 #ifdef _WIN64
35980 static NTSTATUS thunk64_vkGetDescriptorSetHostMappingVALVE(void *args)
35981 {
35982     struct vkGetDescriptorSetHostMappingVALVE_params *params = args;
35983
35984     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), params->ppData);
35985
35986     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetHostMappingVALVE(wine_device_from_handle(params->device)->device, params->descriptorSet, params->ppData);
35987     return STATUS_SUCCESS;
35988 }
35989 #endif /* _WIN64 */
35990
35991 static NTSTATUS thunk32_vkGetDescriptorSetHostMappingVALVE(void *args)
35992 {
35993     struct
35994     {
35995         PTR32 device;
35996         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
35997         PTR32 ppData;
35998     } *params = args;
35999
36000     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorSet), params->ppData);
36001
36002     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetHostMappingVALVE(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorSet, (void **)UlongToPtr(params->ppData));
36003     return STATUS_SUCCESS;
36004 }
36005
36006 #ifdef _WIN64
36007 static NTSTATUS thunk64_vkGetDescriptorSetLayoutBindingOffsetEXT(void *args)
36008 {
36009     struct vkGetDescriptorSetLayoutBindingOffsetEXT_params *params = args;
36010
36011     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->layout), params->binding, params->pOffset);
36012
36013     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutBindingOffsetEXT(wine_device_from_handle(params->device)->device, params->layout, params->binding, params->pOffset);
36014     return STATUS_SUCCESS;
36015 }
36016 #endif /* _WIN64 */
36017
36018 static NTSTATUS thunk32_vkGetDescriptorSetLayoutBindingOffsetEXT(void *args)
36019 {
36020     struct
36021     {
36022         PTR32 device;
36023         VkDescriptorSetLayout DECLSPEC_ALIGN(8) layout;
36024         uint32_t binding;
36025         PTR32 pOffset;
36026     } *params = args;
36027
36028     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->layout), params->binding, params->pOffset);
36029
36030     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetLayoutBindingOffsetEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->layout, params->binding, (VkDeviceSize *)UlongToPtr(params->pOffset));
36031     return STATUS_SUCCESS;
36032 }
36033
36034 #ifdef _WIN64
36035 static NTSTATUS thunk64_vkGetDescriptorSetLayoutHostMappingInfoVALVE(void *args)
36036 {
36037     struct vkGetDescriptorSetLayoutHostMappingInfoVALVE_params *params = args;
36038
36039     TRACE("%p, %p, %p\n", params->device, params->pBindingReference, params->pHostMapping);
36040
36041     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutHostMappingInfoVALVE(wine_device_from_handle(params->device)->device, params->pBindingReference, params->pHostMapping);
36042     return STATUS_SUCCESS;
36043 }
36044 #endif /* _WIN64 */
36045
36046 static NTSTATUS thunk32_vkGetDescriptorSetLayoutHostMappingInfoVALVE(void *args)
36047 {
36048     struct
36049     {
36050         PTR32 device;
36051         PTR32 pBindingReference;
36052         PTR32 pHostMapping;
36053     } *params = args;
36054     VkDescriptorSetBindingReferenceVALVE pBindingReference_host;
36055     VkDescriptorSetLayoutHostMappingInfoVALVE pHostMapping_host;
36056
36057     TRACE("%#x, %#x, %#x\n", params->device, params->pBindingReference, params->pHostMapping);
36058
36059     convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host((const VkDescriptorSetBindingReferenceVALVE32 *)UlongToPtr(params->pBindingReference), &pBindingReference_host);
36060     convert_VkDescriptorSetLayoutHostMappingInfoVALVE_win32_to_host((VkDescriptorSetLayoutHostMappingInfoVALVE32 *)UlongToPtr(params->pHostMapping), &pHostMapping_host);
36061     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetLayoutHostMappingInfoVALVE(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pBindingReference_host, &pHostMapping_host);
36062     convert_VkDescriptorSetLayoutHostMappingInfoVALVE_host_to_win32(&pHostMapping_host, (VkDescriptorSetLayoutHostMappingInfoVALVE32 *)UlongToPtr(params->pHostMapping));
36063     return STATUS_SUCCESS;
36064 }
36065
36066 #ifdef _WIN64
36067 static NTSTATUS thunk64_vkGetDescriptorSetLayoutSizeEXT(void *args)
36068 {
36069     struct vkGetDescriptorSetLayoutSizeEXT_params *params = args;
36070
36071     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->layout), params->pLayoutSizeInBytes);
36072
36073     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSizeEXT(wine_device_from_handle(params->device)->device, params->layout, params->pLayoutSizeInBytes);
36074     return STATUS_SUCCESS;
36075 }
36076 #endif /* _WIN64 */
36077
36078 static NTSTATUS thunk32_vkGetDescriptorSetLayoutSizeEXT(void *args)
36079 {
36080     struct
36081     {
36082         PTR32 device;
36083         VkDescriptorSetLayout DECLSPEC_ALIGN(8) layout;
36084         PTR32 pLayoutSizeInBytes;
36085     } *params = args;
36086
36087     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->layout), params->pLayoutSizeInBytes);
36088
36089     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetLayoutSizeEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->layout, (VkDeviceSize *)UlongToPtr(params->pLayoutSizeInBytes));
36090     return STATUS_SUCCESS;
36091 }
36092
36093 #ifdef _WIN64
36094 static NTSTATUS thunk64_vkGetDescriptorSetLayoutSupport(void *args)
36095 {
36096     struct vkGetDescriptorSetLayoutSupport_params *params = args;
36097
36098     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pSupport);
36099
36100     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSupport(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pSupport);
36101     return STATUS_SUCCESS;
36102 }
36103 #endif /* _WIN64 */
36104
36105 static NTSTATUS thunk32_vkGetDescriptorSetLayoutSupport(void *args)
36106 {
36107     struct
36108     {
36109         PTR32 device;
36110         PTR32 pCreateInfo;
36111         PTR32 pSupport;
36112     } *params = args;
36113     VkDescriptorSetLayoutCreateInfo pCreateInfo_host;
36114     VkDescriptorSetLayoutSupport pSupport_host;
36115     struct conversion_context ctx;
36116
36117     TRACE("%#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pSupport);
36118
36119     init_conversion_context(&ctx);
36120     convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(&ctx, (const VkDescriptorSetLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
36121     convert_VkDescriptorSetLayoutSupport_win32_to_host(&ctx, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport), &pSupport_host);
36122     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetLayoutSupport(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, &pSupport_host);
36123     convert_VkDescriptorSetLayoutSupport_host_to_win32(&pSupport_host, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport));
36124     free_conversion_context(&ctx);
36125     return STATUS_SUCCESS;
36126 }
36127
36128 #ifdef _WIN64
36129 static NTSTATUS thunk64_vkGetDescriptorSetLayoutSupportKHR(void *args)
36130 {
36131     struct vkGetDescriptorSetLayoutSupportKHR_params *params = args;
36132
36133     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pSupport);
36134
36135     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSupportKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pSupport);
36136     return STATUS_SUCCESS;
36137 }
36138 #endif /* _WIN64 */
36139
36140 static NTSTATUS thunk32_vkGetDescriptorSetLayoutSupportKHR(void *args)
36141 {
36142     struct
36143     {
36144         PTR32 device;
36145         PTR32 pCreateInfo;
36146         PTR32 pSupport;
36147     } *params = args;
36148     VkDescriptorSetLayoutCreateInfo pCreateInfo_host;
36149     VkDescriptorSetLayoutSupport pSupport_host;
36150     struct conversion_context ctx;
36151
36152     TRACE("%#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pSupport);
36153
36154     init_conversion_context(&ctx);
36155     convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(&ctx, (const VkDescriptorSetLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
36156     convert_VkDescriptorSetLayoutSupport_win32_to_host(&ctx, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport), &pSupport_host);
36157     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetLayoutSupportKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, &pSupport_host);
36158     convert_VkDescriptorSetLayoutSupport_host_to_win32(&pSupport_host, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport));
36159     free_conversion_context(&ctx);
36160     return STATUS_SUCCESS;
36161 }
36162
36163 #ifdef _WIN64
36164 static NTSTATUS thunk64_vkGetDeviceAccelerationStructureCompatibilityKHR(void *args)
36165 {
36166     struct vkGetDeviceAccelerationStructureCompatibilityKHR_params *params = args;
36167
36168     TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
36169
36170     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceAccelerationStructureCompatibilityKHR(wine_device_from_handle(params->device)->device, params->pVersionInfo, params->pCompatibility);
36171     return STATUS_SUCCESS;
36172 }
36173 #endif /* _WIN64 */
36174
36175 static NTSTATUS thunk32_vkGetDeviceAccelerationStructureCompatibilityKHR(void *args)
36176 {
36177     struct
36178     {
36179         PTR32 device;
36180         PTR32 pVersionInfo;
36181         PTR32 pCompatibility;
36182     } *params = args;
36183     VkAccelerationStructureVersionInfoKHR pVersionInfo_host;
36184
36185     TRACE("%#x, %#x, %#x\n", params->device, params->pVersionInfo, params->pCompatibility);
36186
36187     convert_VkAccelerationStructureVersionInfoKHR_win32_to_host((const VkAccelerationStructureVersionInfoKHR32 *)UlongToPtr(params->pVersionInfo), &pVersionInfo_host);
36188     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceAccelerationStructureCompatibilityKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pVersionInfo_host, (VkAccelerationStructureCompatibilityKHR *)UlongToPtr(params->pCompatibility));
36189     return STATUS_SUCCESS;
36190 }
36191
36192 #ifdef _WIN64
36193 static NTSTATUS thunk64_vkGetDeviceBufferMemoryRequirements(void *args)
36194 {
36195     struct vkGetDeviceBufferMemoryRequirements_params *params = args;
36196
36197     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36198
36199     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceBufferMemoryRequirements(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36200     return STATUS_SUCCESS;
36201 }
36202 #endif /* _WIN64 */
36203
36204 static NTSTATUS thunk32_vkGetDeviceBufferMemoryRequirements(void *args)
36205 {
36206     struct
36207     {
36208         PTR32 device;
36209         PTR32 pInfo;
36210         PTR32 pMemoryRequirements;
36211     } *params = args;
36212     VkDeviceBufferMemoryRequirements pInfo_host;
36213     VkMemoryRequirements2 pMemoryRequirements_host;
36214     struct conversion_context ctx;
36215
36216     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
36217
36218     init_conversion_context(&ctx);
36219     convert_VkDeviceBufferMemoryRequirements_win32_to_host(&ctx, (const VkDeviceBufferMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
36220     convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
36221     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceBufferMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
36222     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
36223     free_conversion_context(&ctx);
36224     return STATUS_SUCCESS;
36225 }
36226
36227 #ifdef _WIN64
36228 static NTSTATUS thunk64_vkGetDeviceBufferMemoryRequirementsKHR(void *args)
36229 {
36230     struct vkGetDeviceBufferMemoryRequirementsKHR_params *params = args;
36231
36232     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36233
36234     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceBufferMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36235     return STATUS_SUCCESS;
36236 }
36237 #endif /* _WIN64 */
36238
36239 static NTSTATUS thunk32_vkGetDeviceBufferMemoryRequirementsKHR(void *args)
36240 {
36241     struct
36242     {
36243         PTR32 device;
36244         PTR32 pInfo;
36245         PTR32 pMemoryRequirements;
36246     } *params = args;
36247     VkDeviceBufferMemoryRequirements pInfo_host;
36248     VkMemoryRequirements2 pMemoryRequirements_host;
36249     struct conversion_context ctx;
36250
36251     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
36252
36253     init_conversion_context(&ctx);
36254     convert_VkDeviceBufferMemoryRequirements_win32_to_host(&ctx, (const VkDeviceBufferMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
36255     convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
36256     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceBufferMemoryRequirementsKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
36257     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
36258     free_conversion_context(&ctx);
36259     return STATUS_SUCCESS;
36260 }
36261
36262 #ifdef _WIN64
36263 static NTSTATUS thunk64_vkGetDeviceFaultInfoEXT(void *args)
36264 {
36265     struct vkGetDeviceFaultInfoEXT_params *params = args;
36266
36267     TRACE("%p, %p, %p\n", params->device, params->pFaultCounts, params->pFaultInfo);
36268
36269     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceFaultInfoEXT(wine_device_from_handle(params->device)->device, params->pFaultCounts, params->pFaultInfo);
36270     return STATUS_SUCCESS;
36271 }
36272 #endif /* _WIN64 */
36273
36274 static NTSTATUS thunk32_vkGetDeviceFaultInfoEXT(void *args)
36275 {
36276     struct
36277     {
36278         PTR32 device;
36279         PTR32 pFaultCounts;
36280         PTR32 pFaultInfo;
36281         VkResult result;
36282     } *params = args;
36283     VkDeviceFaultCountsEXT pFaultCounts_host;
36284     VkDeviceFaultInfoEXT *pFaultInfo_host = NULL;
36285     struct conversion_context ctx;
36286
36287     TRACE("%#x, %#x, %#x\n", params->device, params->pFaultCounts, params->pFaultInfo);
36288
36289     init_conversion_context(&ctx);
36290     convert_VkDeviceFaultCountsEXT_win32_to_host((VkDeviceFaultCountsEXT32 *)UlongToPtr(params->pFaultCounts), &pFaultCounts_host);
36291     if (params->pFaultInfo)
36292     {
36293         pFaultInfo_host = conversion_context_alloc(&ctx, sizeof(*pFaultInfo_host));
36294         convert_VkDeviceFaultInfoEXT_win32_to_host(&ctx, (VkDeviceFaultInfoEXT32 *)UlongToPtr(params->pFaultInfo), pFaultInfo_host);
36295     }
36296     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceFaultInfoEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pFaultCounts_host, pFaultInfo_host);
36297     convert_VkDeviceFaultCountsEXT_host_to_win32(&pFaultCounts_host, (VkDeviceFaultCountsEXT32 *)UlongToPtr(params->pFaultCounts));
36298     convert_VkDeviceFaultInfoEXT_host_to_win32(pFaultInfo_host, (VkDeviceFaultInfoEXT32 *)UlongToPtr(params->pFaultInfo));
36299     free_conversion_context(&ctx);
36300     return STATUS_SUCCESS;
36301 }
36302
36303 #ifdef _WIN64
36304 static NTSTATUS thunk64_vkGetDeviceGroupPeerMemoryFeatures(void *args)
36305 {
36306     struct vkGetDeviceGroupPeerMemoryFeatures_params *params = args;
36307
36308     TRACE("%p, %u, %u, %u, %p\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36309
36310     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPeerMemoryFeatures(wine_device_from_handle(params->device)->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36311     return STATUS_SUCCESS;
36312 }
36313 #endif /* _WIN64 */
36314
36315 static NTSTATUS thunk32_vkGetDeviceGroupPeerMemoryFeatures(void *args)
36316 {
36317     struct
36318     {
36319         PTR32 device;
36320         uint32_t heapIndex;
36321         uint32_t localDeviceIndex;
36322         uint32_t remoteDeviceIndex;
36323         PTR32 pPeerMemoryFeatures;
36324     } *params = args;
36325
36326     TRACE("%#x, %u, %u, %u, %#x\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36327
36328     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceGroupPeerMemoryFeatures(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, (VkPeerMemoryFeatureFlags *)UlongToPtr(params->pPeerMemoryFeatures));
36329     return STATUS_SUCCESS;
36330 }
36331
36332 #ifdef _WIN64
36333 static NTSTATUS thunk64_vkGetDeviceGroupPeerMemoryFeaturesKHR(void *args)
36334 {
36335     struct vkGetDeviceGroupPeerMemoryFeaturesKHR_params *params = args;
36336
36337     TRACE("%p, %u, %u, %u, %p\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36338
36339     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPeerMemoryFeaturesKHR(wine_device_from_handle(params->device)->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36340     return STATUS_SUCCESS;
36341 }
36342 #endif /* _WIN64 */
36343
36344 static NTSTATUS thunk32_vkGetDeviceGroupPeerMemoryFeaturesKHR(void *args)
36345 {
36346     struct
36347     {
36348         PTR32 device;
36349         uint32_t heapIndex;
36350         uint32_t localDeviceIndex;
36351         uint32_t remoteDeviceIndex;
36352         PTR32 pPeerMemoryFeatures;
36353     } *params = args;
36354
36355     TRACE("%#x, %u, %u, %u, %#x\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36356
36357     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceGroupPeerMemoryFeaturesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, (VkPeerMemoryFeatureFlags *)UlongToPtr(params->pPeerMemoryFeatures));
36358     return STATUS_SUCCESS;
36359 }
36360
36361 #ifdef _WIN64
36362 static NTSTATUS thunk64_vkGetDeviceGroupPresentCapabilitiesKHR(void *args)
36363 {
36364     struct vkGetDeviceGroupPresentCapabilitiesKHR_params *params = args;
36365
36366     TRACE("%p, %p\n", params->device, params->pDeviceGroupPresentCapabilities);
36367
36368     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(wine_device_from_handle(params->device)->device, params->pDeviceGroupPresentCapabilities);
36369     return STATUS_SUCCESS;
36370 }
36371 #endif /* _WIN64 */
36372
36373 static NTSTATUS thunk32_vkGetDeviceGroupPresentCapabilitiesKHR(void *args)
36374 {
36375     struct
36376     {
36377         PTR32 device;
36378         PTR32 pDeviceGroupPresentCapabilities;
36379         VkResult result;
36380     } *params = args;
36381     VkDeviceGroupPresentCapabilitiesKHR pDeviceGroupPresentCapabilities_host;
36382
36383     TRACE("%#x, %#x\n", params->device, params->pDeviceGroupPresentCapabilities);
36384
36385     convert_VkDeviceGroupPresentCapabilitiesKHR_win32_to_host((VkDeviceGroupPresentCapabilitiesKHR32 *)UlongToPtr(params->pDeviceGroupPresentCapabilities), &pDeviceGroupPresentCapabilities_host);
36386     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pDeviceGroupPresentCapabilities_host);
36387     convert_VkDeviceGroupPresentCapabilitiesKHR_host_to_win32(&pDeviceGroupPresentCapabilities_host, (VkDeviceGroupPresentCapabilitiesKHR32 *)UlongToPtr(params->pDeviceGroupPresentCapabilities));
36388     return STATUS_SUCCESS;
36389 }
36390
36391 #ifdef _WIN64
36392 static NTSTATUS thunk64_vkGetDeviceGroupSurfacePresentModesKHR(void *args)
36393 {
36394     struct vkGetDeviceGroupSurfacePresentModesKHR_params *params = args;
36395
36396     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->surface), params->pModes);
36397
36398     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);
36399     return STATUS_SUCCESS;
36400 }
36401 #endif /* _WIN64 */
36402
36403 static NTSTATUS thunk32_vkGetDeviceGroupSurfacePresentModesKHR(void *args)
36404 {
36405     struct
36406     {
36407         PTR32 device;
36408         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
36409         PTR32 pModes;
36410         VkResult result;
36411     } *params = args;
36412
36413     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->surface), params->pModes);
36414
36415     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceGroupSurfacePresentModesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, wine_surface_from_handle(params->surface)->driver_surface, (VkDeviceGroupPresentModeFlagsKHR *)UlongToPtr(params->pModes));
36416     return STATUS_SUCCESS;
36417 }
36418
36419 #ifdef _WIN64
36420 static NTSTATUS thunk64_vkGetDeviceImageMemoryRequirements(void *args)
36421 {
36422     struct vkGetDeviceImageMemoryRequirements_params *params = args;
36423
36424     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36425
36426     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageMemoryRequirements(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36427     return STATUS_SUCCESS;
36428 }
36429 #endif /* _WIN64 */
36430
36431 static NTSTATUS thunk32_vkGetDeviceImageMemoryRequirements(void *args)
36432 {
36433     struct
36434     {
36435         PTR32 device;
36436         PTR32 pInfo;
36437         PTR32 pMemoryRequirements;
36438     } *params = args;
36439     VkDeviceImageMemoryRequirements pInfo_host;
36440     VkMemoryRequirements2 pMemoryRequirements_host;
36441     struct conversion_context ctx;
36442
36443     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
36444
36445     init_conversion_context(&ctx);
36446     convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
36447     convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
36448     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceImageMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
36449     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
36450     free_conversion_context(&ctx);
36451     return STATUS_SUCCESS;
36452 }
36453
36454 #ifdef _WIN64
36455 static NTSTATUS thunk64_vkGetDeviceImageMemoryRequirementsKHR(void *args)
36456 {
36457     struct vkGetDeviceImageMemoryRequirementsKHR_params *params = args;
36458
36459     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36460
36461     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36462     return STATUS_SUCCESS;
36463 }
36464 #endif /* _WIN64 */
36465
36466 static NTSTATUS thunk32_vkGetDeviceImageMemoryRequirementsKHR(void *args)
36467 {
36468     struct
36469     {
36470         PTR32 device;
36471         PTR32 pInfo;
36472         PTR32 pMemoryRequirements;
36473     } *params = args;
36474     VkDeviceImageMemoryRequirements pInfo_host;
36475     VkMemoryRequirements2 pMemoryRequirements_host;
36476     struct conversion_context ctx;
36477
36478     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
36479
36480     init_conversion_context(&ctx);
36481     convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
36482     convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
36483     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceImageMemoryRequirementsKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
36484     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
36485     free_conversion_context(&ctx);
36486     return STATUS_SUCCESS;
36487 }
36488
36489 #ifdef _WIN64
36490 static NTSTATUS thunk64_vkGetDeviceImageSparseMemoryRequirements(void *args)
36491 {
36492     struct vkGetDeviceImageSparseMemoryRequirements_params *params = args;
36493
36494     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36495
36496     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageSparseMemoryRequirements(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36497     return STATUS_SUCCESS;
36498 }
36499 #endif /* _WIN64 */
36500
36501 static NTSTATUS thunk32_vkGetDeviceImageSparseMemoryRequirements(void *args)
36502 {
36503     struct
36504     {
36505         PTR32 device;
36506         PTR32 pInfo;
36507         PTR32 pSparseMemoryRequirementCount;
36508         PTR32 pSparseMemoryRequirements;
36509     } *params = args;
36510     VkDeviceImageMemoryRequirements pInfo_host;
36511     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
36512     struct conversion_context ctx;
36513
36514     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36515
36516     init_conversion_context(&ctx);
36517     convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
36518     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
36519     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceImageSparseMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, (uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount), pSparseMemoryRequirements_host);
36520     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
36521     free_conversion_context(&ctx);
36522     return STATUS_SUCCESS;
36523 }
36524
36525 #ifdef _WIN64
36526 static NTSTATUS thunk64_vkGetDeviceImageSparseMemoryRequirementsKHR(void *args)
36527 {
36528     struct vkGetDeviceImageSparseMemoryRequirementsKHR_params *params = args;
36529
36530     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36531
36532     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageSparseMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36533     return STATUS_SUCCESS;
36534 }
36535 #endif /* _WIN64 */
36536
36537 static NTSTATUS thunk32_vkGetDeviceImageSparseMemoryRequirementsKHR(void *args)
36538 {
36539     struct
36540     {
36541         PTR32 device;
36542         PTR32 pInfo;
36543         PTR32 pSparseMemoryRequirementCount;
36544         PTR32 pSparseMemoryRequirements;
36545     } *params = args;
36546     VkDeviceImageMemoryRequirements pInfo_host;
36547     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
36548     struct conversion_context ctx;
36549
36550     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36551
36552     init_conversion_context(&ctx);
36553     convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
36554     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
36555     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceImageSparseMemoryRequirementsKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, (uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount), pSparseMemoryRequirements_host);
36556     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
36557     free_conversion_context(&ctx);
36558     return STATUS_SUCCESS;
36559 }
36560
36561 #ifdef _WIN64
36562 static NTSTATUS thunk64_vkGetDeviceMemoryCommitment(void *args)
36563 {
36564     struct vkGetDeviceMemoryCommitment_params *params = args;
36565
36566     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->memory), params->pCommittedMemoryInBytes);
36567
36568     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryCommitment(wine_device_from_handle(params->device)->device, wine_device_memory_from_handle(params->memory)->memory, params->pCommittedMemoryInBytes);
36569     return STATUS_SUCCESS;
36570 }
36571 #endif /* _WIN64 */
36572
36573 static NTSTATUS thunk32_vkGetDeviceMemoryCommitment(void *args)
36574 {
36575     struct
36576     {
36577         PTR32 device;
36578         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
36579         PTR32 pCommittedMemoryInBytes;
36580     } *params = args;
36581
36582     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->memory), params->pCommittedMemoryInBytes);
36583
36584     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceMemoryCommitment(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, wine_device_memory_from_handle(params->memory)->memory, (VkDeviceSize *)UlongToPtr(params->pCommittedMemoryInBytes));
36585     return STATUS_SUCCESS;
36586 }
36587
36588 #ifdef _WIN64
36589 static NTSTATUS thunk64_vkGetDeviceMemoryOpaqueCaptureAddress(void *args)
36590 {
36591     struct vkGetDeviceMemoryOpaqueCaptureAddress_params *params = args;
36592     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;
36593
36594     TRACE("%p, %p\n", params->device, params->pInfo);
36595
36596     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win64_to_host(params->pInfo, &pInfo_host);
36597     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddress(wine_device_from_handle(params->device)->device, &pInfo_host);
36598     return STATUS_SUCCESS;
36599 }
36600 #endif /* _WIN64 */
36601
36602 static NTSTATUS thunk32_vkGetDeviceMemoryOpaqueCaptureAddress(void *args)
36603 {
36604     struct
36605     {
36606         PTR32 device;
36607         PTR32 pInfo;
36608         uint64_t result;
36609     } *params = args;
36610     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;
36611
36612     TRACE("%#x, %#x\n", params->device, params->pInfo);
36613
36614     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host((const VkDeviceMemoryOpaqueCaptureAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
36615     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddress(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
36616     return STATUS_SUCCESS;
36617 }
36618
36619 #ifdef _WIN64
36620 static NTSTATUS thunk64_vkGetDeviceMemoryOpaqueCaptureAddressKHR(void *args)
36621 {
36622     struct vkGetDeviceMemoryOpaqueCaptureAddressKHR_params *params = args;
36623     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;
36624
36625     TRACE("%p, %p\n", params->device, params->pInfo);
36626
36627     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win64_to_host(params->pInfo, &pInfo_host);
36628     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
36629     return STATUS_SUCCESS;
36630 }
36631 #endif /* _WIN64 */
36632
36633 static NTSTATUS thunk32_vkGetDeviceMemoryOpaqueCaptureAddressKHR(void *args)
36634 {
36635     struct
36636     {
36637         PTR32 device;
36638         PTR32 pInfo;
36639         uint64_t result;
36640     } *params = args;
36641     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;
36642
36643     TRACE("%#x, %#x\n", params->device, params->pInfo);
36644
36645     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host((const VkDeviceMemoryOpaqueCaptureAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
36646     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
36647     return STATUS_SUCCESS;
36648 }
36649
36650 #ifdef _WIN64
36651 static NTSTATUS thunk64_vkGetDeviceMicromapCompatibilityEXT(void *args)
36652 {
36653     struct vkGetDeviceMicromapCompatibilityEXT_params *params = args;
36654
36655     TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
36656
36657     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMicromapCompatibilityEXT(wine_device_from_handle(params->device)->device, params->pVersionInfo, params->pCompatibility);
36658     return STATUS_SUCCESS;
36659 }
36660 #endif /* _WIN64 */
36661
36662 static NTSTATUS thunk32_vkGetDeviceMicromapCompatibilityEXT(void *args)
36663 {
36664     struct
36665     {
36666         PTR32 device;
36667         PTR32 pVersionInfo;
36668         PTR32 pCompatibility;
36669     } *params = args;
36670     VkMicromapVersionInfoEXT pVersionInfo_host;
36671
36672     TRACE("%#x, %#x, %#x\n", params->device, params->pVersionInfo, params->pCompatibility);
36673
36674     convert_VkMicromapVersionInfoEXT_win32_to_host((const VkMicromapVersionInfoEXT32 *)UlongToPtr(params->pVersionInfo), &pVersionInfo_host);
36675     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceMicromapCompatibilityEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pVersionInfo_host, (VkAccelerationStructureCompatibilityKHR *)UlongToPtr(params->pCompatibility));
36676     return STATUS_SUCCESS;
36677 }
36678
36679 #ifdef _WIN64
36680 static NTSTATUS thunk64_vkGetDeviceQueue(void *args)
36681 {
36682     struct vkGetDeviceQueue_params *params = args;
36683
36684     TRACE("%p, %u, %u, %p\n", params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
36685
36686     wine_vkGetDeviceQueue(params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
36687     return STATUS_SUCCESS;
36688 }
36689 #endif /* _WIN64 */
36690
36691 static NTSTATUS thunk32_vkGetDeviceQueue(void *args)
36692 {
36693     struct
36694     {
36695         PTR32 device;
36696         uint32_t queueFamilyIndex;
36697         uint32_t queueIndex;
36698         PTR32 pQueue;
36699     } *params = args;
36700     VkQueue pQueue_host;
36701
36702     TRACE("%#x, %u, %u, %#x\n", params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
36703
36704     pQueue_host = UlongToPtr(*(PTR32 *)UlongToPtr(params->pQueue));
36705     wine_vkGetDeviceQueue((VkDevice)UlongToPtr(params->device), params->queueFamilyIndex, params->queueIndex, &pQueue_host);
36706     *(PTR32 *)UlongToPtr(params->pQueue) = PtrToUlong(pQueue_host);
36707     return STATUS_SUCCESS;
36708 }
36709
36710 #ifdef _WIN64
36711 static NTSTATUS thunk64_vkGetDeviceQueue2(void *args)
36712 {
36713     struct vkGetDeviceQueue2_params *params = args;
36714
36715     TRACE("%p, %p, %p\n", params->device, params->pQueueInfo, params->pQueue);
36716
36717     wine_vkGetDeviceQueue2(params->device, params->pQueueInfo, params->pQueue);
36718     return STATUS_SUCCESS;
36719 }
36720 #endif /* _WIN64 */
36721
36722 static NTSTATUS thunk32_vkGetDeviceQueue2(void *args)
36723 {
36724     struct
36725     {
36726         PTR32 device;
36727         PTR32 pQueueInfo;
36728         PTR32 pQueue;
36729     } *params = args;
36730     VkDeviceQueueInfo2 pQueueInfo_host;
36731     VkQueue pQueue_host;
36732
36733     TRACE("%#x, %#x, %#x\n", params->device, params->pQueueInfo, params->pQueue);
36734
36735     convert_VkDeviceQueueInfo2_win32_to_host((const VkDeviceQueueInfo232 *)UlongToPtr(params->pQueueInfo), &pQueueInfo_host);
36736     pQueue_host = UlongToPtr(*(PTR32 *)UlongToPtr(params->pQueue));
36737     wine_vkGetDeviceQueue2((VkDevice)UlongToPtr(params->device), &pQueueInfo_host, &pQueue_host);
36738     *(PTR32 *)UlongToPtr(params->pQueue) = PtrToUlong(pQueue_host);
36739     return STATUS_SUCCESS;
36740 }
36741
36742 #ifdef _WIN64
36743 static NTSTATUS thunk64_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(void *args)
36744 {
36745     struct vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_params *params = args;
36746
36747     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderpass), params->pMaxWorkgroupSize);
36748
36749     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(wine_device_from_handle(params->device)->device, params->renderpass, params->pMaxWorkgroupSize);
36750     return STATUS_SUCCESS;
36751 }
36752 #endif /* _WIN64 */
36753
36754 static NTSTATUS thunk32_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(void *args)
36755 {
36756     struct
36757     {
36758         PTR32 device;
36759         VkRenderPass DECLSPEC_ALIGN(8) renderpass;
36760         PTR32 pMaxWorkgroupSize;
36761         VkResult result;
36762     } *params = args;
36763
36764     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->renderpass), params->pMaxWorkgroupSize);
36765
36766     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->renderpass, (VkExtent2D *)UlongToPtr(params->pMaxWorkgroupSize));
36767     return STATUS_SUCCESS;
36768 }
36769
36770 #ifdef _WIN64
36771 static NTSTATUS thunk64_vkGetDynamicRenderingTilePropertiesQCOM(void *args)
36772 {
36773     struct vkGetDynamicRenderingTilePropertiesQCOM_params *params = args;
36774
36775     TRACE("%p, %p, %p\n", params->device, params->pRenderingInfo, params->pProperties);
36776
36777     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDynamicRenderingTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->pRenderingInfo, params->pProperties);
36778     return STATUS_SUCCESS;
36779 }
36780 #endif /* _WIN64 */
36781
36782 static NTSTATUS thunk32_vkGetDynamicRenderingTilePropertiesQCOM(void *args)
36783 {
36784     struct
36785     {
36786         PTR32 device;
36787         PTR32 pRenderingInfo;
36788         PTR32 pProperties;
36789         VkResult result;
36790     } *params = args;
36791     VkRenderingInfo pRenderingInfo_host;
36792     VkTilePropertiesQCOM pProperties_host;
36793     struct conversion_context ctx;
36794
36795     TRACE("%#x, %#x, %#x\n", params->device, params->pRenderingInfo, params->pProperties);
36796
36797     init_conversion_context(&ctx);
36798     convert_VkRenderingInfo_win32_to_host(&ctx, (const VkRenderingInfo32 *)UlongToPtr(params->pRenderingInfo), &pRenderingInfo_host);
36799     convert_VkTilePropertiesQCOM_win32_to_host((VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties), &pProperties_host);
36800     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDynamicRenderingTilePropertiesQCOM(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pRenderingInfo_host, &pProperties_host);
36801     convert_VkTilePropertiesQCOM_host_to_win32(&pProperties_host, (VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties));
36802     free_conversion_context(&ctx);
36803     return STATUS_SUCCESS;
36804 }
36805
36806 #ifdef _WIN64
36807 static NTSTATUS thunk64_vkGetEventStatus(void *args)
36808 {
36809     struct vkGetEventStatus_params *params = args;
36810
36811     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
36812
36813     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetEventStatus(wine_device_from_handle(params->device)->device, params->event);
36814     return STATUS_SUCCESS;
36815 }
36816 #endif /* _WIN64 */
36817
36818 static NTSTATUS thunk32_vkGetEventStatus(void *args)
36819 {
36820     struct
36821     {
36822         PTR32 device;
36823         VkEvent DECLSPEC_ALIGN(8) event;
36824         VkResult result;
36825     } *params = args;
36826
36827     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
36828
36829     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetEventStatus(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event);
36830     return STATUS_SUCCESS;
36831 }
36832
36833 #ifdef _WIN64
36834 static NTSTATUS thunk64_vkGetFenceStatus(void *args)
36835 {
36836     struct vkGetFenceStatus_params *params = args;
36837
36838     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->fence));
36839
36840     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFenceStatus(wine_device_from_handle(params->device)->device, params->fence);
36841     return STATUS_SUCCESS;
36842 }
36843 #endif /* _WIN64 */
36844
36845 static NTSTATUS thunk32_vkGetFenceStatus(void *args)
36846 {
36847     struct
36848     {
36849         PTR32 device;
36850         VkFence DECLSPEC_ALIGN(8) fence;
36851         VkResult result;
36852     } *params = args;
36853
36854     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->fence));
36855
36856     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetFenceStatus(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->fence);
36857     return STATUS_SUCCESS;
36858 }
36859
36860 #ifdef _WIN64
36861 static NTSTATUS thunk64_vkGetFramebufferTilePropertiesQCOM(void *args)
36862 {
36863     struct vkGetFramebufferTilePropertiesQCOM_params *params = args;
36864
36865     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pPropertiesCount, params->pProperties);
36866
36867     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFramebufferTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->framebuffer, params->pPropertiesCount, params->pProperties);
36868     return STATUS_SUCCESS;
36869 }
36870 #endif /* _WIN64 */
36871
36872 static NTSTATUS thunk32_vkGetFramebufferTilePropertiesQCOM(void *args)
36873 {
36874     struct
36875     {
36876         PTR32 device;
36877         VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
36878         PTR32 pPropertiesCount;
36879         PTR32 pProperties;
36880         VkResult result;
36881     } *params = args;
36882     VkTilePropertiesQCOM *pProperties_host;
36883     struct conversion_context ctx;
36884
36885     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pPropertiesCount, params->pProperties);
36886
36887     init_conversion_context(&ctx);
36888     pProperties_host = convert_VkTilePropertiesQCOM_array_win32_to_host(&ctx, (VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertiesCount));
36889     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetFramebufferTilePropertiesQCOM(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->framebuffer, (uint32_t *)UlongToPtr(params->pPropertiesCount), pProperties_host);
36890     convert_VkTilePropertiesQCOM_array_host_to_win32(pProperties_host, (VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertiesCount));
36891     free_conversion_context(&ctx);
36892     return STATUS_SUCCESS;
36893 }
36894
36895 #ifdef _WIN64
36896 static NTSTATUS thunk64_vkGetGeneratedCommandsMemoryRequirementsNV(void *args)
36897 {
36898     struct vkGetGeneratedCommandsMemoryRequirementsNV_params *params = args;
36899
36900     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36901
36902     wine_device_from_handle(params->device)->funcs.p_vkGetGeneratedCommandsMemoryRequirementsNV(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36903     return STATUS_SUCCESS;
36904 }
36905 #endif /* _WIN64 */
36906
36907 static NTSTATUS thunk32_vkGetGeneratedCommandsMemoryRequirementsNV(void *args)
36908 {
36909     struct
36910     {
36911         PTR32 device;
36912         PTR32 pInfo;
36913         PTR32 pMemoryRequirements;
36914     } *params = args;
36915     VkGeneratedCommandsMemoryRequirementsInfoNV pInfo_host;
36916     VkMemoryRequirements2 pMemoryRequirements_host;
36917     struct conversion_context ctx;
36918
36919     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
36920
36921     init_conversion_context(&ctx);
36922     convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host((const VkGeneratedCommandsMemoryRequirementsInfoNV32 *)UlongToPtr(params->pInfo), &pInfo_host);
36923     convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
36924     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetGeneratedCommandsMemoryRequirementsNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
36925     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
36926     free_conversion_context(&ctx);
36927     return STATUS_SUCCESS;
36928 }
36929
36930 #ifdef _WIN64
36931 static NTSTATUS thunk64_vkGetImageMemoryRequirements(void *args)
36932 {
36933     struct vkGetImageMemoryRequirements_params *params = args;
36934
36935     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pMemoryRequirements);
36936
36937     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements(wine_device_from_handle(params->device)->device, params->image, params->pMemoryRequirements);
36938     return STATUS_SUCCESS;
36939 }
36940 #endif /* _WIN64 */
36941
36942 static NTSTATUS thunk32_vkGetImageMemoryRequirements(void *args)
36943 {
36944     struct
36945     {
36946         PTR32 device;
36947         VkImage DECLSPEC_ALIGN(8) image;
36948         PTR32 pMemoryRequirements;
36949     } *params = args;
36950     VkMemoryRequirements pMemoryRequirements_host;
36951
36952     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pMemoryRequirements);
36953
36954     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, &pMemoryRequirements_host);
36955     convert_VkMemoryRequirements_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements32 *)UlongToPtr(params->pMemoryRequirements));
36956     return STATUS_SUCCESS;
36957 }
36958
36959 #ifdef _WIN64
36960 static NTSTATUS thunk64_vkGetImageMemoryRequirements2(void *args)
36961 {
36962     struct vkGetImageMemoryRequirements2_params *params = args;
36963
36964     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36965
36966     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements2(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36967     return STATUS_SUCCESS;
36968 }
36969 #endif /* _WIN64 */
36970
36971 static NTSTATUS thunk32_vkGetImageMemoryRequirements2(void *args)
36972 {
36973     struct
36974     {
36975         PTR32 device;
36976         PTR32 pInfo;
36977         PTR32 pMemoryRequirements;
36978     } *params = args;
36979     VkImageMemoryRequirementsInfo2 pInfo_host;
36980     VkMemoryRequirements2 pMemoryRequirements_host;
36981     struct conversion_context ctx;
36982
36983     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
36984
36985     init_conversion_context(&ctx);
36986     convert_VkImageMemoryRequirementsInfo2_win32_to_host(&ctx, (const VkImageMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
36987     convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
36988     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageMemoryRequirements2(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
36989     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
36990     free_conversion_context(&ctx);
36991     return STATUS_SUCCESS;
36992 }
36993
36994 #ifdef _WIN64
36995 static NTSTATUS thunk64_vkGetImageMemoryRequirements2KHR(void *args)
36996 {
36997     struct vkGetImageMemoryRequirements2KHR_params *params = args;
36998
36999     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
37000
37001     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
37002     return STATUS_SUCCESS;
37003 }
37004 #endif /* _WIN64 */
37005
37006 static NTSTATUS thunk32_vkGetImageMemoryRequirements2KHR(void *args)
37007 {
37008     struct
37009     {
37010         PTR32 device;
37011         PTR32 pInfo;
37012         PTR32 pMemoryRequirements;
37013     } *params = args;
37014     VkImageMemoryRequirementsInfo2 pInfo_host;
37015     VkMemoryRequirements2 pMemoryRequirements_host;
37016     struct conversion_context ctx;
37017
37018     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
37019
37020     init_conversion_context(&ctx);
37021     convert_VkImageMemoryRequirementsInfo2_win32_to_host(&ctx, (const VkImageMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
37022     convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
37023     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageMemoryRequirements2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
37024     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
37025     free_conversion_context(&ctx);
37026     return STATUS_SUCCESS;
37027 }
37028
37029 #ifdef _WIN64
37030 static NTSTATUS thunk64_vkGetImageOpaqueCaptureDescriptorDataEXT(void *args)
37031 {
37032     struct vkGetImageOpaqueCaptureDescriptorDataEXT_params *params = args;
37033
37034     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
37035
37036     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
37037     return STATUS_SUCCESS;
37038 }
37039 #endif /* _WIN64 */
37040
37041 static NTSTATUS thunk32_vkGetImageOpaqueCaptureDescriptorDataEXT(void *args)
37042 {
37043     struct
37044     {
37045         PTR32 device;
37046         PTR32 pInfo;
37047         PTR32 pData;
37048         VkResult result;
37049     } *params = args;
37050     VkImageCaptureDescriptorDataInfoEXT pInfo_host;
37051
37052     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
37053
37054     convert_VkImageCaptureDescriptorDataInfoEXT_win32_to_host((const VkImageCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
37055     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageOpaqueCaptureDescriptorDataEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, (void *)UlongToPtr(params->pData));
37056     return STATUS_SUCCESS;
37057 }
37058
37059 #ifdef _WIN64
37060 static NTSTATUS thunk64_vkGetImageSparseMemoryRequirements(void *args)
37061 {
37062     struct vkGetImageSparseMemoryRequirements_params *params = args;
37063
37064     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37065
37066     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements(wine_device_from_handle(params->device)->device, params->image, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37067     return STATUS_SUCCESS;
37068 }
37069 #endif /* _WIN64 */
37070
37071 static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements(void *args)
37072 {
37073     struct
37074     {
37075         PTR32 device;
37076         VkImage DECLSPEC_ALIGN(8) image;
37077         PTR32 pSparseMemoryRequirementCount;
37078         PTR32 pSparseMemoryRequirements;
37079     } *params = args;
37080     VkSparseImageMemoryRequirements *pSparseMemoryRequirements_host;
37081     struct conversion_context ctx;
37082
37083     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37084
37085     init_conversion_context(&ctx);
37086     pSparseMemoryRequirements_host = (params->pSparseMemoryRequirements && *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount)) ? conversion_context_alloc(&ctx, sizeof(*pSparseMemoryRequirements_host) * *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount)) : NULL;
37087     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageSparseMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, (uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount), pSparseMemoryRequirements_host);
37088     convert_VkSparseImageMemoryRequirements_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements32 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
37089     free_conversion_context(&ctx);
37090     return STATUS_SUCCESS;
37091 }
37092
37093 #ifdef _WIN64
37094 static NTSTATUS thunk64_vkGetImageSparseMemoryRequirements2(void *args)
37095 {
37096     struct vkGetImageSparseMemoryRequirements2_params *params = args;
37097
37098     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37099
37100     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements2(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37101     return STATUS_SUCCESS;
37102 }
37103 #endif /* _WIN64 */
37104
37105 static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements2(void *args)
37106 {
37107     struct
37108     {
37109         PTR32 device;
37110         PTR32 pInfo;
37111         PTR32 pSparseMemoryRequirementCount;
37112         PTR32 pSparseMemoryRequirements;
37113     } *params = args;
37114     VkImageSparseMemoryRequirementsInfo2 pInfo_host;
37115     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
37116     struct conversion_context ctx;
37117
37118     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37119
37120     init_conversion_context(&ctx);
37121     convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host((const VkImageSparseMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
37122     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
37123     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageSparseMemoryRequirements2(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, (uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount), pSparseMemoryRequirements_host);
37124     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
37125     free_conversion_context(&ctx);
37126     return STATUS_SUCCESS;
37127 }
37128
37129 #ifdef _WIN64
37130 static NTSTATUS thunk64_vkGetImageSparseMemoryRequirements2KHR(void *args)
37131 {
37132     struct vkGetImageSparseMemoryRequirements2KHR_params *params = args;
37133
37134     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37135
37136     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37137     return STATUS_SUCCESS;
37138 }
37139 #endif /* _WIN64 */
37140
37141 static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements2KHR(void *args)
37142 {
37143     struct
37144     {
37145         PTR32 device;
37146         PTR32 pInfo;
37147         PTR32 pSparseMemoryRequirementCount;
37148         PTR32 pSparseMemoryRequirements;
37149     } *params = args;
37150     VkImageSparseMemoryRequirementsInfo2 pInfo_host;
37151     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
37152     struct conversion_context ctx;
37153
37154     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37155
37156     init_conversion_context(&ctx);
37157     convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host((const VkImageSparseMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
37158     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
37159     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageSparseMemoryRequirements2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, (uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount), pSparseMemoryRequirements_host);
37160     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
37161     free_conversion_context(&ctx);
37162     return STATUS_SUCCESS;
37163 }
37164
37165 #ifdef _WIN64
37166 static NTSTATUS thunk64_vkGetImageSubresourceLayout(void *args)
37167 {
37168     struct vkGetImageSubresourceLayout_params *params = args;
37169
37170     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
37171
37172     wine_device_from_handle(params->device)->funcs.p_vkGetImageSubresourceLayout(wine_device_from_handle(params->device)->device, params->image, params->pSubresource, params->pLayout);
37173     return STATUS_SUCCESS;
37174 }
37175 #endif /* _WIN64 */
37176
37177 static NTSTATUS thunk32_vkGetImageSubresourceLayout(void *args)
37178 {
37179     struct
37180     {
37181         PTR32 device;
37182         VkImage DECLSPEC_ALIGN(8) image;
37183         PTR32 pSubresource;
37184         PTR32 pLayout;
37185     } *params = args;
37186     VkSubresourceLayout pLayout_host;
37187
37188     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
37189
37190     convert_VkSubresourceLayout_win32_to_host((VkSubresourceLayout32 *)UlongToPtr(params->pLayout), &pLayout_host);
37191     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageSubresourceLayout(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, (const VkImageSubresource *)UlongToPtr(params->pSubresource), &pLayout_host);
37192     convert_VkSubresourceLayout_host_to_win32(&pLayout_host, (VkSubresourceLayout32 *)UlongToPtr(params->pLayout));
37193     return STATUS_SUCCESS;
37194 }
37195
37196 #ifdef _WIN64
37197 static NTSTATUS thunk64_vkGetImageSubresourceLayout2EXT(void *args)
37198 {
37199     struct vkGetImageSubresourceLayout2EXT_params *params = args;
37200
37201     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
37202
37203     wine_device_from_handle(params->device)->funcs.p_vkGetImageSubresourceLayout2EXT(wine_device_from_handle(params->device)->device, params->image, params->pSubresource, params->pLayout);
37204     return STATUS_SUCCESS;
37205 }
37206 #endif /* _WIN64 */
37207
37208 static NTSTATUS thunk32_vkGetImageSubresourceLayout2EXT(void *args)
37209 {
37210     struct
37211     {
37212         PTR32 device;
37213         VkImage DECLSPEC_ALIGN(8) image;
37214         PTR32 pSubresource;
37215         PTR32 pLayout;
37216     } *params = args;
37217     VkImageSubresource2EXT pSubresource_host;
37218     VkSubresourceLayout2EXT pLayout_host;
37219     struct conversion_context ctx;
37220
37221     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
37222
37223     init_conversion_context(&ctx);
37224     convert_VkImageSubresource2EXT_win32_to_host((const VkImageSubresource2EXT32 *)UlongToPtr(params->pSubresource), &pSubresource_host);
37225     convert_VkSubresourceLayout2EXT_win32_to_host(&ctx, (VkSubresourceLayout2EXT32 *)UlongToPtr(params->pLayout), &pLayout_host);
37226     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageSubresourceLayout2EXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, &pSubresource_host, &pLayout_host);
37227     convert_VkSubresourceLayout2EXT_host_to_win32(&pLayout_host, (VkSubresourceLayout2EXT32 *)UlongToPtr(params->pLayout));
37228     free_conversion_context(&ctx);
37229     return STATUS_SUCCESS;
37230 }
37231
37232 #ifdef _WIN64
37233 static NTSTATUS thunk64_vkGetImageViewAddressNVX(void *args)
37234 {
37235     struct vkGetImageViewAddressNVX_params *params = args;
37236
37237     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pProperties);
37238
37239     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewAddressNVX(wine_device_from_handle(params->device)->device, params->imageView, params->pProperties);
37240     return STATUS_SUCCESS;
37241 }
37242 #endif /* _WIN64 */
37243
37244 static NTSTATUS thunk32_vkGetImageViewAddressNVX(void *args)
37245 {
37246     struct
37247     {
37248         PTR32 device;
37249         VkImageView DECLSPEC_ALIGN(8) imageView;
37250         PTR32 pProperties;
37251         VkResult result;
37252     } *params = args;
37253     VkImageViewAddressPropertiesNVX pProperties_host;
37254
37255     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->imageView), params->pProperties);
37256
37257     convert_VkImageViewAddressPropertiesNVX_win32_to_host((VkImageViewAddressPropertiesNVX32 *)UlongToPtr(params->pProperties), &pProperties_host);
37258     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageViewAddressNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->imageView, &pProperties_host);
37259     convert_VkImageViewAddressPropertiesNVX_host_to_win32(&pProperties_host, (VkImageViewAddressPropertiesNVX32 *)UlongToPtr(params->pProperties));
37260     return STATUS_SUCCESS;
37261 }
37262
37263 #ifdef _WIN64
37264 static NTSTATUS thunk64_vkGetImageViewHandleNVX(void *args)
37265 {
37266     struct vkGetImageViewHandleNVX_params *params = args;
37267
37268     TRACE("%p, %p\n", params->device, params->pInfo);
37269
37270     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewHandleNVX(wine_device_from_handle(params->device)->device, params->pInfo);
37271     return STATUS_SUCCESS;
37272 }
37273 #endif /* _WIN64 */
37274
37275 static NTSTATUS thunk32_vkGetImageViewHandleNVX(void *args)
37276 {
37277     struct
37278     {
37279         PTR32 device;
37280         PTR32 pInfo;
37281         uint32_t result;
37282     } *params = args;
37283     VkImageViewHandleInfoNVX pInfo_host;
37284
37285     TRACE("%#x, %#x\n", params->device, params->pInfo);
37286
37287     convert_VkImageViewHandleInfoNVX_win32_to_host((const VkImageViewHandleInfoNVX32 *)UlongToPtr(params->pInfo), &pInfo_host);
37288     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageViewHandleNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
37289     return STATUS_SUCCESS;
37290 }
37291
37292 #ifdef _WIN64
37293 static NTSTATUS thunk64_vkGetImageViewOpaqueCaptureDescriptorDataEXT(void *args)
37294 {
37295     struct vkGetImageViewOpaqueCaptureDescriptorDataEXT_params *params = args;
37296
37297     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
37298
37299     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
37300     return STATUS_SUCCESS;
37301 }
37302 #endif /* _WIN64 */
37303
37304 static NTSTATUS thunk32_vkGetImageViewOpaqueCaptureDescriptorDataEXT(void *args)
37305 {
37306     struct
37307     {
37308         PTR32 device;
37309         PTR32 pInfo;
37310         PTR32 pData;
37311         VkResult result;
37312     } *params = args;
37313     VkImageViewCaptureDescriptorDataInfoEXT pInfo_host;
37314
37315     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
37316
37317     convert_VkImageViewCaptureDescriptorDataInfoEXT_win32_to_host((const VkImageViewCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
37318     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageViewOpaqueCaptureDescriptorDataEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, (void *)UlongToPtr(params->pData));
37319     return STATUS_SUCCESS;
37320 }
37321
37322 #ifdef _WIN64
37323 static NTSTATUS thunk64_vkGetMemoryHostPointerPropertiesEXT(void *args)
37324 {
37325     struct vkGetMemoryHostPointerPropertiesEXT_params *params = args;
37326
37327     TRACE("%p, %#x, %p, %p\n", params->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
37328
37329     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetMemoryHostPointerPropertiesEXT(wine_device_from_handle(params->device)->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
37330     return STATUS_SUCCESS;
37331 }
37332 #endif /* _WIN64 */
37333
37334 static NTSTATUS thunk32_vkGetMemoryHostPointerPropertiesEXT(void *args)
37335 {
37336     struct
37337     {
37338         PTR32 device;
37339         VkExternalMemoryHandleTypeFlagBits handleType;
37340         PTR32 pHostPointer;
37341         PTR32 pMemoryHostPointerProperties;
37342         VkResult result;
37343     } *params = args;
37344     VkMemoryHostPointerPropertiesEXT pMemoryHostPointerProperties_host;
37345
37346     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
37347
37348     convert_VkMemoryHostPointerPropertiesEXT_win32_to_host((VkMemoryHostPointerPropertiesEXT32 *)UlongToPtr(params->pMemoryHostPointerProperties), &pMemoryHostPointerProperties_host);
37349     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetMemoryHostPointerPropertiesEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->handleType, (const void *)UlongToPtr(params->pHostPointer), &pMemoryHostPointerProperties_host);
37350     convert_VkMemoryHostPointerPropertiesEXT_host_to_win32(&pMemoryHostPointerProperties_host, (VkMemoryHostPointerPropertiesEXT32 *)UlongToPtr(params->pMemoryHostPointerProperties));
37351     return STATUS_SUCCESS;
37352 }
37353
37354 #ifdef _WIN64
37355 static NTSTATUS thunk64_vkGetMicromapBuildSizesEXT(void *args)
37356 {
37357     struct vkGetMicromapBuildSizesEXT_params *params = args;
37358
37359     TRACE("%p, %#x, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
37360
37361     wine_device_from_handle(params->device)->funcs.p_vkGetMicromapBuildSizesEXT(wine_device_from_handle(params->device)->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
37362     return STATUS_SUCCESS;
37363 }
37364 #endif /* _WIN64 */
37365
37366 static NTSTATUS thunk32_vkGetMicromapBuildSizesEXT(void *args)
37367 {
37368     struct
37369     {
37370         PTR32 device;
37371         VkAccelerationStructureBuildTypeKHR buildType;
37372         PTR32 pBuildInfo;
37373         PTR32 pSizeInfo;
37374     } *params = args;
37375     VkMicromapBuildInfoEXT pBuildInfo_host;
37376     VkMicromapBuildSizesInfoEXT pSizeInfo_host;
37377     struct conversion_context ctx;
37378
37379     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
37380
37381     init_conversion_context(&ctx);
37382     convert_VkMicromapBuildInfoEXT_win32_to_host(&ctx, (const VkMicromapBuildInfoEXT32 *)UlongToPtr(params->pBuildInfo), &pBuildInfo_host);
37383     convert_VkMicromapBuildSizesInfoEXT_win32_to_host((VkMicromapBuildSizesInfoEXT32 *)UlongToPtr(params->pSizeInfo), &pSizeInfo_host);
37384     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetMicromapBuildSizesEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->buildType, &pBuildInfo_host, &pSizeInfo_host);
37385     convert_VkMicromapBuildSizesInfoEXT_host_to_win32(&pSizeInfo_host, (VkMicromapBuildSizesInfoEXT32 *)UlongToPtr(params->pSizeInfo));
37386     free_conversion_context(&ctx);
37387     return STATUS_SUCCESS;
37388 }
37389
37390 #ifdef _WIN64
37391 static NTSTATUS thunk64_vkGetPerformanceParameterINTEL(void *args)
37392 {
37393     struct vkGetPerformanceParameterINTEL_params *params = args;
37394
37395     TRACE("%p, %#x, %p\n", params->device, params->parameter, params->pValue);
37396
37397     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPerformanceParameterINTEL(wine_device_from_handle(params->device)->device, params->parameter, params->pValue);
37398     return STATUS_SUCCESS;
37399 }
37400 #endif /* _WIN64 */
37401
37402 static NTSTATUS thunk32_vkGetPerformanceParameterINTEL(void *args)
37403 {
37404     struct
37405     {
37406         PTR32 device;
37407         VkPerformanceParameterTypeINTEL parameter;
37408         PTR32 pValue;
37409         VkResult result;
37410     } *params = args;
37411     VkPerformanceValueINTEL pValue_host;
37412
37413     TRACE("%#x, %#x, %#x\n", params->device, params->parameter, params->pValue);
37414
37415     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPerformanceParameterINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->parameter, &pValue_host);
37416     convert_VkPerformanceValueINTEL_host_to_win32(&pValue_host, (VkPerformanceValueINTEL32 *)UlongToPtr(params->pValue));
37417     return STATUS_SUCCESS;
37418 }
37419
37420 #ifdef _WIN64
37421 static NTSTATUS thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *args)
37422 {
37423     struct vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_params *params = args;
37424
37425     TRACE("%p, %p, %p\n", params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
37426
37427     params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
37428     return STATUS_SUCCESS;
37429 }
37430 #endif /* _WIN64 */
37431
37432 static NTSTATUS thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *args)
37433 {
37434     struct
37435     {
37436         PTR32 physicalDevice;
37437         PTR32 pTimeDomainCount;
37438         PTR32 pTimeDomains;
37439         VkResult result;
37440     } *params = args;
37441
37442     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
37443
37444     params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT((VkPhysicalDevice)UlongToPtr(params->physicalDevice), (uint32_t *)UlongToPtr(params->pTimeDomainCount), (VkTimeDomainEXT *)UlongToPtr(params->pTimeDomains));
37445     return STATUS_SUCCESS;
37446 }
37447
37448 #ifdef _WIN64
37449 static NTSTATUS thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(void *args)
37450 {
37451     struct vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_params *params = args;
37452
37453     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
37454
37455     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);
37456     return STATUS_SUCCESS;
37457 }
37458 #endif /* _WIN64 */
37459
37460 static NTSTATUS thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(void *args)
37461 {
37462     struct
37463     {
37464         PTR32 physicalDevice;
37465         PTR32 pPropertyCount;
37466         PTR32 pProperties;
37467         VkResult result;
37468     } *params = args;
37469     VkCooperativeMatrixPropertiesNV *pProperties_host;
37470     struct conversion_context ctx;
37471
37472     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
37473
37474     init_conversion_context(&ctx);
37475     pProperties_host = convert_VkCooperativeMatrixPropertiesNV_array_win32_to_host(&ctx, (VkCooperativeMatrixPropertiesNV32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
37476     params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (uint32_t *)UlongToPtr(params->pPropertyCount), pProperties_host);
37477     convert_VkCooperativeMatrixPropertiesNV_array_host_to_win32(pProperties_host, (VkCooperativeMatrixPropertiesNV32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
37478     free_conversion_context(&ctx);
37479     return STATUS_SUCCESS;
37480 }
37481
37482 #ifdef _WIN64
37483 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalBufferProperties(void *args)
37484 {
37485     struct vkGetPhysicalDeviceExternalBufferProperties_params *params = args;
37486
37487     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37488
37489     wine_vkGetPhysicalDeviceExternalBufferProperties(params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37490     return STATUS_SUCCESS;
37491 }
37492 #endif /* _WIN64 */
37493
37494 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalBufferProperties(void *args)
37495 {
37496     struct
37497     {
37498         PTR32 physicalDevice;
37499         PTR32 pExternalBufferInfo;
37500         PTR32 pExternalBufferProperties;
37501     } *params = args;
37502     VkPhysicalDeviceExternalBufferInfo pExternalBufferInfo_host;
37503     VkExternalBufferProperties pExternalBufferProperties_host;
37504
37505     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37506
37507     convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host((const VkPhysicalDeviceExternalBufferInfo32 *)UlongToPtr(params->pExternalBufferInfo), &pExternalBufferInfo_host);
37508     convert_VkExternalBufferProperties_win32_to_host((VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties), &pExternalBufferProperties_host);
37509     wine_vkGetPhysicalDeviceExternalBufferProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalBufferInfo_host, &pExternalBufferProperties_host);
37510     convert_VkExternalBufferProperties_host_to_win32(&pExternalBufferProperties_host, (VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties));
37511     return STATUS_SUCCESS;
37512 }
37513
37514 #ifdef _WIN64
37515 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalBufferPropertiesKHR(void *args)
37516 {
37517     struct vkGetPhysicalDeviceExternalBufferPropertiesKHR_params *params = args;
37518
37519     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37520
37521     wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37522     return STATUS_SUCCESS;
37523 }
37524 #endif /* _WIN64 */
37525
37526 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalBufferPropertiesKHR(void *args)
37527 {
37528     struct
37529     {
37530         PTR32 physicalDevice;
37531         PTR32 pExternalBufferInfo;
37532         PTR32 pExternalBufferProperties;
37533     } *params = args;
37534     VkPhysicalDeviceExternalBufferInfo pExternalBufferInfo_host;
37535     VkExternalBufferProperties pExternalBufferProperties_host;
37536
37537     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37538
37539     convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host((const VkPhysicalDeviceExternalBufferInfo32 *)UlongToPtr(params->pExternalBufferInfo), &pExternalBufferInfo_host);
37540     convert_VkExternalBufferProperties_win32_to_host((VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties), &pExternalBufferProperties_host);
37541     wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalBufferInfo_host, &pExternalBufferProperties_host);
37542     convert_VkExternalBufferProperties_host_to_win32(&pExternalBufferProperties_host, (VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties));
37543     return STATUS_SUCCESS;
37544 }
37545
37546 #ifdef _WIN64
37547 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalFenceProperties(void *args)
37548 {
37549     struct vkGetPhysicalDeviceExternalFenceProperties_params *params = args;
37550
37551     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
37552
37553     wine_vkGetPhysicalDeviceExternalFenceProperties(params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
37554     return STATUS_SUCCESS;
37555 }
37556 #endif /* _WIN64 */
37557
37558 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalFenceProperties(void *args)
37559 {
37560     struct
37561     {
37562         PTR32 physicalDevice;
37563         PTR32 pExternalFenceInfo;
37564         PTR32 pExternalFenceProperties;
37565     } *params = args;
37566     VkPhysicalDeviceExternalFenceInfo pExternalFenceInfo_host;
37567     VkExternalFenceProperties pExternalFenceProperties_host;
37568
37569     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
37570
37571     convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host((const VkPhysicalDeviceExternalFenceInfo32 *)UlongToPtr(params->pExternalFenceInfo), &pExternalFenceInfo_host);
37572     convert_VkExternalFenceProperties_win32_to_host((VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties), &pExternalFenceProperties_host);
37573     wine_vkGetPhysicalDeviceExternalFenceProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalFenceInfo_host, &pExternalFenceProperties_host);
37574     convert_VkExternalFenceProperties_host_to_win32(&pExternalFenceProperties_host, (VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties));
37575     return STATUS_SUCCESS;
37576 }
37577
37578 #ifdef _WIN64
37579 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalFencePropertiesKHR(void *args)
37580 {
37581     struct vkGetPhysicalDeviceExternalFencePropertiesKHR_params *params = args;
37582
37583     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
37584
37585     wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
37586     return STATUS_SUCCESS;
37587 }
37588 #endif /* _WIN64 */
37589
37590 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalFencePropertiesKHR(void *args)
37591 {
37592     struct
37593     {
37594         PTR32 physicalDevice;
37595         PTR32 pExternalFenceInfo;
37596         PTR32 pExternalFenceProperties;
37597     } *params = args;
37598     VkPhysicalDeviceExternalFenceInfo pExternalFenceInfo_host;
37599     VkExternalFenceProperties pExternalFenceProperties_host;
37600
37601     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
37602
37603     convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host((const VkPhysicalDeviceExternalFenceInfo32 *)UlongToPtr(params->pExternalFenceInfo), &pExternalFenceInfo_host);
37604     convert_VkExternalFenceProperties_win32_to_host((VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties), &pExternalFenceProperties_host);
37605     wine_vkGetPhysicalDeviceExternalFencePropertiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalFenceInfo_host, &pExternalFenceProperties_host);
37606     convert_VkExternalFenceProperties_host_to_win32(&pExternalFenceProperties_host, (VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties));
37607     return STATUS_SUCCESS;
37608 }
37609
37610 #ifdef _WIN64
37611 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalSemaphoreProperties(void *args)
37612 {
37613     struct vkGetPhysicalDeviceExternalSemaphoreProperties_params *params = args;
37614
37615     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
37616
37617     wine_vkGetPhysicalDeviceExternalSemaphoreProperties(params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
37618     return STATUS_SUCCESS;
37619 }
37620 #endif /* _WIN64 */
37621
37622 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalSemaphoreProperties(void *args)
37623 {
37624     struct
37625     {
37626         PTR32 physicalDevice;
37627         PTR32 pExternalSemaphoreInfo;
37628         PTR32 pExternalSemaphoreProperties;
37629     } *params = args;
37630     VkPhysicalDeviceExternalSemaphoreInfo pExternalSemaphoreInfo_host;
37631     VkExternalSemaphoreProperties pExternalSemaphoreProperties_host;
37632     struct conversion_context ctx;
37633
37634     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
37635
37636     init_conversion_context(&ctx);
37637     convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(&ctx, (const VkPhysicalDeviceExternalSemaphoreInfo32 *)UlongToPtr(params->pExternalSemaphoreInfo), &pExternalSemaphoreInfo_host);
37638     convert_VkExternalSemaphoreProperties_win32_to_host((VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties), &pExternalSemaphoreProperties_host);
37639     wine_vkGetPhysicalDeviceExternalSemaphoreProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalSemaphoreInfo_host, &pExternalSemaphoreProperties_host);
37640     convert_VkExternalSemaphoreProperties_host_to_win32(&pExternalSemaphoreProperties_host, (VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties));
37641     free_conversion_context(&ctx);
37642     return STATUS_SUCCESS;
37643 }
37644
37645 #ifdef _WIN64
37646 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(void *args)
37647 {
37648     struct vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_params *params = args;
37649
37650     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
37651
37652     wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
37653     return STATUS_SUCCESS;
37654 }
37655 #endif /* _WIN64 */
37656
37657 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(void *args)
37658 {
37659     struct
37660     {
37661         PTR32 physicalDevice;
37662         PTR32 pExternalSemaphoreInfo;
37663         PTR32 pExternalSemaphoreProperties;
37664     } *params = args;
37665     VkPhysicalDeviceExternalSemaphoreInfo pExternalSemaphoreInfo_host;
37666     VkExternalSemaphoreProperties pExternalSemaphoreProperties_host;
37667     struct conversion_context ctx;
37668
37669     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
37670
37671     init_conversion_context(&ctx);
37672     convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(&ctx, (const VkPhysicalDeviceExternalSemaphoreInfo32 *)UlongToPtr(params->pExternalSemaphoreInfo), &pExternalSemaphoreInfo_host);
37673     convert_VkExternalSemaphoreProperties_win32_to_host((VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties), &pExternalSemaphoreProperties_host);
37674     wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalSemaphoreInfo_host, &pExternalSemaphoreProperties_host);
37675     convert_VkExternalSemaphoreProperties_host_to_win32(&pExternalSemaphoreProperties_host, (VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties));
37676     free_conversion_context(&ctx);
37677     return STATUS_SUCCESS;
37678 }
37679
37680 #ifdef _WIN64
37681 static NTSTATUS thunk64_vkGetPhysicalDeviceFeatures(void *args)
37682 {
37683     struct vkGetPhysicalDeviceFeatures_params *params = args;
37684
37685     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
37686
37687     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
37688     return STATUS_SUCCESS;
37689 }
37690 #endif /* _WIN64 */
37691
37692 static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures(void *args)
37693 {
37694     struct
37695     {
37696         PTR32 physicalDevice;
37697         PTR32 pFeatures;
37698     } *params = args;
37699
37700     TRACE("%#x, %#x\n", params->physicalDevice, params->pFeatures);
37701
37702     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceFeatures(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (VkPhysicalDeviceFeatures *)UlongToPtr(params->pFeatures));
37703     return STATUS_SUCCESS;
37704 }
37705
37706 #ifdef _WIN64
37707 static NTSTATUS thunk64_vkGetPhysicalDeviceFeatures2(void *args)
37708 {
37709     struct vkGetPhysicalDeviceFeatures2_params *params = args;
37710
37711     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
37712
37713     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
37714     return STATUS_SUCCESS;
37715 }
37716 #endif /* _WIN64 */
37717
37718 static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures2(void *args)
37719 {
37720     struct
37721     {
37722         PTR32 physicalDevice;
37723         PTR32 pFeatures;
37724     } *params = args;
37725     VkPhysicalDeviceFeatures2 pFeatures_host;
37726     struct conversion_context ctx;
37727
37728     TRACE("%#x, %#x\n", params->physicalDevice, params->pFeatures);
37729
37730     init_conversion_context(&ctx);
37731     convert_VkPhysicalDeviceFeatures2_win32_to_host(&ctx, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures), &pFeatures_host);
37732     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceFeatures2(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pFeatures_host);
37733     convert_VkPhysicalDeviceFeatures2_host_to_win32(&pFeatures_host, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures));
37734     free_conversion_context(&ctx);
37735     return STATUS_SUCCESS;
37736 }
37737
37738 #ifdef _WIN64
37739 static NTSTATUS thunk64_vkGetPhysicalDeviceFeatures2KHR(void *args)
37740 {
37741     struct vkGetPhysicalDeviceFeatures2KHR_params *params = args;
37742
37743     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
37744
37745     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
37746     return STATUS_SUCCESS;
37747 }
37748 #endif /* _WIN64 */
37749
37750 static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures2KHR(void *args)
37751 {
37752     struct
37753     {
37754         PTR32 physicalDevice;
37755         PTR32 pFeatures;
37756     } *params = args;
37757     VkPhysicalDeviceFeatures2 pFeatures_host;
37758     struct conversion_context ctx;
37759
37760     TRACE("%#x, %#x\n", params->physicalDevice, params->pFeatures);
37761
37762     init_conversion_context(&ctx);
37763     convert_VkPhysicalDeviceFeatures2_win32_to_host(&ctx, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures), &pFeatures_host);
37764     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceFeatures2KHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pFeatures_host);
37765     convert_VkPhysicalDeviceFeatures2_host_to_win32(&pFeatures_host, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures));
37766     free_conversion_context(&ctx);
37767     return STATUS_SUCCESS;
37768 }
37769
37770 #ifdef _WIN64
37771 static NTSTATUS thunk64_vkGetPhysicalDeviceFormatProperties(void *args)
37772 {
37773     struct vkGetPhysicalDeviceFormatProperties_params *params = args;
37774
37775     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
37776
37777     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
37778     return STATUS_SUCCESS;
37779 }
37780 #endif /* _WIN64 */
37781
37782 static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties(void *args)
37783 {
37784     struct
37785     {
37786         PTR32 physicalDevice;
37787         VkFormat format;
37788         PTR32 pFormatProperties;
37789     } *params = args;
37790
37791     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->format, params->pFormatProperties);
37792
37793     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->format, (VkFormatProperties *)UlongToPtr(params->pFormatProperties));
37794     return STATUS_SUCCESS;
37795 }
37796
37797 #ifdef _WIN64
37798 static NTSTATUS thunk64_vkGetPhysicalDeviceFormatProperties2(void *args)
37799 {
37800     struct vkGetPhysicalDeviceFormatProperties2_params *params = args;
37801
37802     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
37803
37804     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
37805     return STATUS_SUCCESS;
37806 }
37807 #endif /* _WIN64 */
37808
37809 static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties2(void *args)
37810 {
37811     struct
37812     {
37813         PTR32 physicalDevice;
37814         VkFormat format;
37815         PTR32 pFormatProperties;
37816     } *params = args;
37817     VkFormatProperties2 pFormatProperties_host;
37818     struct conversion_context ctx;
37819
37820     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->format, params->pFormatProperties);
37821
37822     init_conversion_context(&ctx);
37823     convert_VkFormatProperties2_win32_to_host(&ctx, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties), &pFormatProperties_host);
37824     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->format, &pFormatProperties_host);
37825     convert_VkFormatProperties2_host_to_win32(&pFormatProperties_host, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties));
37826     free_conversion_context(&ctx);
37827     return STATUS_SUCCESS;
37828 }
37829
37830 #ifdef _WIN64
37831 static NTSTATUS thunk64_vkGetPhysicalDeviceFormatProperties2KHR(void *args)
37832 {
37833     struct vkGetPhysicalDeviceFormatProperties2KHR_params *params = args;
37834
37835     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
37836
37837     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
37838     return STATUS_SUCCESS;
37839 }
37840 #endif /* _WIN64 */
37841
37842 static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties2KHR(void *args)
37843 {
37844     struct
37845     {
37846         PTR32 physicalDevice;
37847         VkFormat format;
37848         PTR32 pFormatProperties;
37849     } *params = args;
37850     VkFormatProperties2 pFormatProperties_host;
37851     struct conversion_context ctx;
37852
37853     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->format, params->pFormatProperties);
37854
37855     init_conversion_context(&ctx);
37856     convert_VkFormatProperties2_win32_to_host(&ctx, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties), &pFormatProperties_host);
37857     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2KHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->format, &pFormatProperties_host);
37858     convert_VkFormatProperties2_host_to_win32(&pFormatProperties_host, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties));
37859     free_conversion_context(&ctx);
37860     return STATUS_SUCCESS;
37861 }
37862
37863 #ifdef _WIN64
37864 static NTSTATUS thunk64_vkGetPhysicalDeviceFragmentShadingRatesKHR(void *args)
37865 {
37866     struct vkGetPhysicalDeviceFragmentShadingRatesKHR_params *params = args;
37867
37868     TRACE("%p, %p, %p\n", params->physicalDevice, params->pFragmentShadingRateCount, params->pFragmentShadingRates);
37869
37870     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);
37871     return STATUS_SUCCESS;
37872 }
37873 #endif /* _WIN64 */
37874
37875 static NTSTATUS thunk32_vkGetPhysicalDeviceFragmentShadingRatesKHR(void *args)
37876 {
37877     struct
37878     {
37879         PTR32 physicalDevice;
37880         PTR32 pFragmentShadingRateCount;
37881         PTR32 pFragmentShadingRates;
37882         VkResult result;
37883     } *params = args;
37884     VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates_host;
37885     struct conversion_context ctx;
37886
37887     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pFragmentShadingRateCount, params->pFragmentShadingRates);
37888
37889     init_conversion_context(&ctx);
37890     pFragmentShadingRates_host = convert_VkPhysicalDeviceFragmentShadingRateKHR_array_win32_to_host(&ctx, (VkPhysicalDeviceFragmentShadingRateKHR32 *)UlongToPtr(params->pFragmentShadingRates), *(uint32_t *)UlongToPtr(params->pFragmentShadingRateCount));
37891     params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceFragmentShadingRatesKHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (uint32_t *)UlongToPtr(params->pFragmentShadingRateCount), pFragmentShadingRates_host);
37892     convert_VkPhysicalDeviceFragmentShadingRateKHR_array_host_to_win32(pFragmentShadingRates_host, (VkPhysicalDeviceFragmentShadingRateKHR32 *)UlongToPtr(params->pFragmentShadingRates), *(uint32_t *)UlongToPtr(params->pFragmentShadingRateCount));
37893     free_conversion_context(&ctx);
37894     return STATUS_SUCCESS;
37895 }
37896
37897 #ifdef _WIN64
37898 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties(void *args)
37899 {
37900     struct vkGetPhysicalDeviceImageFormatProperties_params *params = args;
37901
37902     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p\n", params->physicalDevice, params->format, params->type, params->tiling, params->usage, params->flags, params->pImageFormatProperties);
37903
37904     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);
37905     return STATUS_SUCCESS;
37906 }
37907 #endif /* _WIN64 */
37908
37909 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties(void *args)
37910 {
37911     struct
37912     {
37913         PTR32 physicalDevice;
37914         VkFormat format;
37915         VkImageType type;
37916         VkImageTiling tiling;
37917         VkImageUsageFlags usage;
37918         VkImageCreateFlags flags;
37919         PTR32 pImageFormatProperties;
37920         VkResult result;
37921     } *params = args;
37922     VkImageFormatProperties pImageFormatProperties_host;
37923
37924     TRACE("%#x, %#x, %#x, %#x, %#x, %#x, %#x\n", params->physicalDevice, params->format, params->type, params->tiling, params->usage, params->flags, params->pImageFormatProperties);
37925
37926     params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->format, params->type, params->tiling, params->usage, params->flags, &pImageFormatProperties_host);
37927     convert_VkImageFormatProperties_host_to_win32(&pImageFormatProperties_host, (VkImageFormatProperties32 *)UlongToPtr(params->pImageFormatProperties));
37928     return STATUS_SUCCESS;
37929 }
37930
37931 #ifdef _WIN64
37932 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties2(void *args)
37933 {
37934     struct vkGetPhysicalDeviceImageFormatProperties2_params *params = args;
37935
37936     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
37937
37938     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
37939     return STATUS_SUCCESS;
37940 }
37941 #endif /* _WIN64 */
37942
37943 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties2(void *args)
37944 {
37945     struct
37946     {
37947         PTR32 physicalDevice;
37948         PTR32 pImageFormatInfo;
37949         PTR32 pImageFormatProperties;
37950         VkResult result;
37951     } *params = args;
37952     VkPhysicalDeviceImageFormatInfo2 pImageFormatInfo_host;
37953     VkImageFormatProperties2 pImageFormatProperties_host;
37954     struct conversion_context ctx;
37955
37956     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
37957
37958     init_conversion_context(&ctx);
37959     convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(&ctx, (const VkPhysicalDeviceImageFormatInfo232 *)UlongToPtr(params->pImageFormatInfo), &pImageFormatInfo_host);
37960     convert_VkImageFormatProperties2_win32_to_host(&ctx, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties), &pImageFormatProperties_host);
37961     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pImageFormatInfo_host, &pImageFormatProperties_host);
37962     convert_VkImageFormatProperties2_host_to_win32(&pImageFormatProperties_host, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties));
37963     free_conversion_context(&ctx);
37964     return STATUS_SUCCESS;
37965 }
37966
37967 #ifdef _WIN64
37968 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties2KHR(void *args)
37969 {
37970     struct vkGetPhysicalDeviceImageFormatProperties2KHR_params *params = args;
37971
37972     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
37973
37974     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
37975     return STATUS_SUCCESS;
37976 }
37977 #endif /* _WIN64 */
37978
37979 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties2KHR(void *args)
37980 {
37981     struct
37982     {
37983         PTR32 physicalDevice;
37984         PTR32 pImageFormatInfo;
37985         PTR32 pImageFormatProperties;
37986         VkResult result;
37987     } *params = args;
37988     VkPhysicalDeviceImageFormatInfo2 pImageFormatInfo_host;
37989     VkImageFormatProperties2 pImageFormatProperties_host;
37990     struct conversion_context ctx;
37991
37992     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
37993
37994     init_conversion_context(&ctx);
37995     convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(&ctx, (const VkPhysicalDeviceImageFormatInfo232 *)UlongToPtr(params->pImageFormatInfo), &pImageFormatInfo_host);
37996     convert_VkImageFormatProperties2_win32_to_host(&ctx, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties), &pImageFormatProperties_host);
37997     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pImageFormatInfo_host, &pImageFormatProperties_host);
37998     convert_VkImageFormatProperties2_host_to_win32(&pImageFormatProperties_host, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties));
37999     free_conversion_context(&ctx);
38000     return STATUS_SUCCESS;
38001 }
38002
38003 #ifdef _WIN64
38004 static NTSTATUS thunk64_vkGetPhysicalDeviceMemoryProperties(void *args)
38005 {
38006     struct vkGetPhysicalDeviceMemoryProperties_params *params = args;
38007
38008     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
38009
38010     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pMemoryProperties);
38011     return STATUS_SUCCESS;
38012 }
38013 #endif /* _WIN64 */
38014
38015 static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties(void *args)
38016 {
38017     struct
38018     {
38019         PTR32 physicalDevice;
38020         PTR32 pMemoryProperties;
38021     } *params = args;
38022     VkPhysicalDeviceMemoryProperties pMemoryProperties_host;
38023
38024     TRACE("%#x, %#x\n", params->physicalDevice, params->pMemoryProperties);
38025
38026     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pMemoryProperties_host);
38027     convert_VkPhysicalDeviceMemoryProperties_host_to_win32(&pMemoryProperties_host, (VkPhysicalDeviceMemoryProperties32 *)UlongToPtr(params->pMemoryProperties));
38028     return STATUS_SUCCESS;
38029 }
38030
38031 #ifdef _WIN64
38032 static NTSTATUS thunk64_vkGetPhysicalDeviceMemoryProperties2(void *args)
38033 {
38034     struct vkGetPhysicalDeviceMemoryProperties2_params *params = args;
38035
38036     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
38037
38038     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pMemoryProperties);
38039     return STATUS_SUCCESS;
38040 }
38041 #endif /* _WIN64 */
38042
38043 static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties2(void *args)
38044 {
38045     struct
38046     {
38047         PTR32 physicalDevice;
38048         PTR32 pMemoryProperties;
38049     } *params = args;
38050     VkPhysicalDeviceMemoryProperties2 pMemoryProperties_host;
38051     struct conversion_context ctx;
38052
38053     TRACE("%#x, %#x\n", params->physicalDevice, params->pMemoryProperties);
38054
38055     init_conversion_context(&ctx);
38056     convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(&ctx, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties), &pMemoryProperties_host);
38057     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pMemoryProperties_host);
38058     convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(&pMemoryProperties_host, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties));
38059     free_conversion_context(&ctx);
38060     return STATUS_SUCCESS;
38061 }
38062
38063 #ifdef _WIN64
38064 static NTSTATUS thunk64_vkGetPhysicalDeviceMemoryProperties2KHR(void *args)
38065 {
38066     struct vkGetPhysicalDeviceMemoryProperties2KHR_params *params = args;
38067
38068     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
38069
38070     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pMemoryProperties);
38071     return STATUS_SUCCESS;
38072 }
38073 #endif /* _WIN64 */
38074
38075 static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties2KHR(void *args)
38076 {
38077     struct
38078     {
38079         PTR32 physicalDevice;
38080         PTR32 pMemoryProperties;
38081     } *params = args;
38082     VkPhysicalDeviceMemoryProperties2 pMemoryProperties_host;
38083     struct conversion_context ctx;
38084
38085     TRACE("%#x, %#x\n", params->physicalDevice, params->pMemoryProperties);
38086
38087     init_conversion_context(&ctx);
38088     convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(&ctx, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties), &pMemoryProperties_host);
38089     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2KHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pMemoryProperties_host);
38090     convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(&pMemoryProperties_host, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties));
38091     free_conversion_context(&ctx);
38092     return STATUS_SUCCESS;
38093 }
38094
38095 #ifdef _WIN64
38096 static NTSTATUS thunk64_vkGetPhysicalDeviceMultisamplePropertiesEXT(void *args)
38097 {
38098     struct vkGetPhysicalDeviceMultisamplePropertiesEXT_params *params = args;
38099
38100     TRACE("%p, %#x, %p\n", params->physicalDevice, params->samples, params->pMultisampleProperties);
38101
38102     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMultisamplePropertiesEXT(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->samples, params->pMultisampleProperties);
38103     return STATUS_SUCCESS;
38104 }
38105 #endif /* _WIN64 */
38106
38107 static NTSTATUS thunk32_vkGetPhysicalDeviceMultisamplePropertiesEXT(void *args)
38108 {
38109     struct
38110     {
38111         PTR32 physicalDevice;
38112         VkSampleCountFlagBits samples;
38113         PTR32 pMultisampleProperties;
38114     } *params = args;
38115     VkMultisamplePropertiesEXT pMultisampleProperties_host;
38116
38117     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->samples, params->pMultisampleProperties);
38118
38119     convert_VkMultisamplePropertiesEXT_win32_to_host((VkMultisamplePropertiesEXT32 *)UlongToPtr(params->pMultisampleProperties), &pMultisampleProperties_host);
38120     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceMultisamplePropertiesEXT(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->samples, &pMultisampleProperties_host);
38121     convert_VkMultisamplePropertiesEXT_host_to_win32(&pMultisampleProperties_host, (VkMultisamplePropertiesEXT32 *)UlongToPtr(params->pMultisampleProperties));
38122     return STATUS_SUCCESS;
38123 }
38124
38125 #ifdef _WIN64
38126 static NTSTATUS thunk64_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(void *args)
38127 {
38128     struct vkGetPhysicalDeviceOpticalFlowImageFormatsNV_params *params = args;
38129
38130     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pOpticalFlowImageFormatInfo, params->pFormatCount, params->pImageFormatProperties);
38131
38132     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);
38133     return STATUS_SUCCESS;
38134 }
38135 #endif /* _WIN64 */
38136
38137 static NTSTATUS thunk32_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(void *args)
38138 {
38139     struct
38140     {
38141         PTR32 physicalDevice;
38142         PTR32 pOpticalFlowImageFormatInfo;
38143         PTR32 pFormatCount;
38144         PTR32 pImageFormatProperties;
38145         VkResult result;
38146     } *params = args;
38147     VkOpticalFlowImageFormatInfoNV pOpticalFlowImageFormatInfo_host;
38148     VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties_host;
38149     struct conversion_context ctx;
38150
38151     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pOpticalFlowImageFormatInfo, params->pFormatCount, params->pImageFormatProperties);
38152
38153     init_conversion_context(&ctx);
38154     convert_VkOpticalFlowImageFormatInfoNV_win32_to_host((const VkOpticalFlowImageFormatInfoNV32 *)UlongToPtr(params->pOpticalFlowImageFormatInfo), &pOpticalFlowImageFormatInfo_host);
38155     pImageFormatProperties_host = convert_VkOpticalFlowImageFormatPropertiesNV_array_win32_to_host(&ctx, (VkOpticalFlowImageFormatPropertiesNV32 *)UlongToPtr(params->pImageFormatProperties), *(uint32_t *)UlongToPtr(params->pFormatCount));
38156     params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pOpticalFlowImageFormatInfo_host, (uint32_t *)UlongToPtr(params->pFormatCount), pImageFormatProperties_host);
38157     convert_VkOpticalFlowImageFormatPropertiesNV_array_host_to_win32(pImageFormatProperties_host, (VkOpticalFlowImageFormatPropertiesNV32 *)UlongToPtr(params->pImageFormatProperties), *(uint32_t *)UlongToPtr(params->pFormatCount));
38158     free_conversion_context(&ctx);
38159     return STATUS_SUCCESS;
38160 }
38161
38162 #ifdef _WIN64
38163 static NTSTATUS thunk64_vkGetPhysicalDevicePresentRectanglesKHR(void *args)
38164 {
38165     struct vkGetPhysicalDevicePresentRectanglesKHR_params *params = args;
38166
38167     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pRectCount, params->pRects);
38168
38169     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);
38170     return STATUS_SUCCESS;
38171 }
38172 #endif /* _WIN64 */
38173
38174 static NTSTATUS thunk32_vkGetPhysicalDevicePresentRectanglesKHR(void *args)
38175 {
38176     struct
38177     {
38178         PTR32 physicalDevice;
38179         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
38180         PTR32 pRectCount;
38181         PTR32 pRects;
38182         VkResult result;
38183     } *params = args;
38184
38185     TRACE("%#x, 0x%s, %#x, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pRectCount, params->pRects);
38186
38187     params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDevicePresentRectanglesKHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, (uint32_t *)UlongToPtr(params->pRectCount), (VkRect2D *)UlongToPtr(params->pRects));
38188     return STATUS_SUCCESS;
38189 }
38190
38191 #ifdef _WIN64
38192 static NTSTATUS thunk64_vkGetPhysicalDeviceProperties(void *args)
38193 {
38194     struct vkGetPhysicalDeviceProperties_params *params = args;
38195
38196     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
38197
38198     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pProperties);
38199     return STATUS_SUCCESS;
38200 }
38201 #endif /* _WIN64 */
38202
38203 static NTSTATUS thunk32_vkGetPhysicalDeviceProperties(void *args)
38204 {
38205     struct
38206     {
38207         PTR32 physicalDevice;
38208         PTR32 pProperties;
38209     } *params = args;
38210     VkPhysicalDeviceProperties pProperties_host;
38211
38212     TRACE("%#x, %#x\n", params->physicalDevice, params->pProperties);
38213
38214     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceProperties(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pProperties_host);
38215     convert_VkPhysicalDeviceProperties_host_to_win32(&pProperties_host, (VkPhysicalDeviceProperties32 *)UlongToPtr(params->pProperties));
38216     return STATUS_SUCCESS;
38217 }
38218
38219 #ifdef _WIN64
38220 static NTSTATUS thunk64_vkGetPhysicalDeviceProperties2(void *args)
38221 {
38222     struct vkGetPhysicalDeviceProperties2_params *params = args;
38223
38224     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
38225
38226     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pProperties);
38227     return STATUS_SUCCESS;
38228 }
38229 #endif /* _WIN64 */
38230
38231 static NTSTATUS thunk32_vkGetPhysicalDeviceProperties2(void *args)
38232 {
38233     struct
38234     {
38235         PTR32 physicalDevice;
38236         PTR32 pProperties;
38237     } *params = args;
38238     VkPhysicalDeviceProperties2 pProperties_host;
38239     struct conversion_context ctx;
38240
38241     TRACE("%#x, %#x\n", params->physicalDevice, params->pProperties);
38242
38243     init_conversion_context(&ctx);
38244     convert_VkPhysicalDeviceProperties2_win32_to_host(&ctx, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties), &pProperties_host);
38245     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceProperties2(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pProperties_host);
38246     convert_VkPhysicalDeviceProperties2_host_to_win32(&pProperties_host, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties));
38247     free_conversion_context(&ctx);
38248     return STATUS_SUCCESS;
38249 }
38250
38251 #ifdef _WIN64
38252 static NTSTATUS thunk64_vkGetPhysicalDeviceProperties2KHR(void *args)
38253 {
38254     struct vkGetPhysicalDeviceProperties2KHR_params *params = args;
38255
38256     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
38257
38258     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pProperties);
38259     return STATUS_SUCCESS;
38260 }
38261 #endif /* _WIN64 */
38262
38263 static NTSTATUS thunk32_vkGetPhysicalDeviceProperties2KHR(void *args)
38264 {
38265     struct
38266     {
38267         PTR32 physicalDevice;
38268         PTR32 pProperties;
38269     } *params = args;
38270     VkPhysicalDeviceProperties2 pProperties_host;
38271     struct conversion_context ctx;
38272
38273     TRACE("%#x, %#x\n", params->physicalDevice, params->pProperties);
38274
38275     init_conversion_context(&ctx);
38276     convert_VkPhysicalDeviceProperties2_win32_to_host(&ctx, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties), &pProperties_host);
38277     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pProperties_host);
38278     convert_VkPhysicalDeviceProperties2_host_to_win32(&pProperties_host, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties));
38279     free_conversion_context(&ctx);
38280     return STATUS_SUCCESS;
38281 }
38282
38283 #ifdef _WIN64
38284 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(void *args)
38285 {
38286     struct vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_params *params = args;
38287
38288     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPerformanceQueryCreateInfo, params->pNumPasses);
38289
38290     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pPerformanceQueryCreateInfo, params->pNumPasses);
38291     return STATUS_SUCCESS;
38292 }
38293 #endif /* _WIN64 */
38294
38295 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(void *args)
38296 {
38297     struct
38298     {
38299         PTR32 physicalDevice;
38300         PTR32 pPerformanceQueryCreateInfo;
38301         PTR32 pNumPasses;
38302     } *params = args;
38303     VkQueryPoolPerformanceCreateInfoKHR pPerformanceQueryCreateInfo_host;
38304
38305     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pPerformanceQueryCreateInfo, params->pNumPasses);
38306
38307     convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host((const VkQueryPoolPerformanceCreateInfoKHR32 *)UlongToPtr(params->pPerformanceQueryCreateInfo), &pPerformanceQueryCreateInfo_host);
38308     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pPerformanceQueryCreateInfo_host, (uint32_t *)UlongToPtr(params->pNumPasses));
38309     return STATUS_SUCCESS;
38310 }
38311
38312 #ifdef _WIN64
38313 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyProperties(void *args)
38314 {
38315     struct vkGetPhysicalDeviceQueueFamilyProperties_params *params = args;
38316
38317     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38318
38319     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38320     return STATUS_SUCCESS;
38321 }
38322 #endif /* _WIN64 */
38323
38324 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties(void *args)
38325 {
38326     struct
38327     {
38328         PTR32 physicalDevice;
38329         PTR32 pQueueFamilyPropertyCount;
38330         PTR32 pQueueFamilyProperties;
38331     } *params = args;
38332
38333     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38334
38335     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount), (VkQueueFamilyProperties *)UlongToPtr(params->pQueueFamilyProperties));
38336     return STATUS_SUCCESS;
38337 }
38338
38339 #ifdef _WIN64
38340 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyProperties2(void *args)
38341 {
38342     struct vkGetPhysicalDeviceQueueFamilyProperties2_params *params = args;
38343
38344     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38345
38346     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38347     return STATUS_SUCCESS;
38348 }
38349 #endif /* _WIN64 */
38350
38351 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties2(void *args)
38352 {
38353     struct
38354     {
38355         PTR32 physicalDevice;
38356         PTR32 pQueueFamilyPropertyCount;
38357         PTR32 pQueueFamilyProperties;
38358     } *params = args;
38359     VkQueueFamilyProperties2 *pQueueFamilyProperties_host;
38360     struct conversion_context ctx;
38361
38362     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38363
38364     init_conversion_context(&ctx);
38365     pQueueFamilyProperties_host = convert_VkQueueFamilyProperties2_array_win32_to_host(&ctx, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
38366     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount), pQueueFamilyProperties_host);
38367     convert_VkQueueFamilyProperties2_array_host_to_win32(pQueueFamilyProperties_host, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
38368     free_conversion_context(&ctx);
38369     return STATUS_SUCCESS;
38370 }
38371
38372 #ifdef _WIN64
38373 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyProperties2KHR(void *args)
38374 {
38375     struct vkGetPhysicalDeviceQueueFamilyProperties2KHR_params *params = args;
38376
38377     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38378
38379     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38380     return STATUS_SUCCESS;
38381 }
38382 #endif /* _WIN64 */
38383
38384 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties2KHR(void *args)
38385 {
38386     struct
38387     {
38388         PTR32 physicalDevice;
38389         PTR32 pQueueFamilyPropertyCount;
38390         PTR32 pQueueFamilyProperties;
38391     } *params = args;
38392     VkQueueFamilyProperties2 *pQueueFamilyProperties_host;
38393     struct conversion_context ctx;
38394
38395     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38396
38397     init_conversion_context(&ctx);
38398     pQueueFamilyProperties_host = convert_VkQueueFamilyProperties2_array_win32_to_host(&ctx, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
38399     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount), pQueueFamilyProperties_host);
38400     convert_VkQueueFamilyProperties2_array_host_to_win32(pQueueFamilyProperties_host, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
38401     free_conversion_context(&ctx);
38402     return STATUS_SUCCESS;
38403 }
38404
38405 #ifdef _WIN64
38406 static NTSTATUS thunk64_vkGetPhysicalDeviceSparseImageFormatProperties(void *args)
38407 {
38408     struct vkGetPhysicalDeviceSparseImageFormatProperties_params *params = args;
38409
38410     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);
38411
38412     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);
38413     return STATUS_SUCCESS;
38414 }
38415 #endif /* _WIN64 */
38416
38417 static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties(void *args)
38418 {
38419     struct
38420     {
38421         PTR32 physicalDevice;
38422         VkFormat format;
38423         VkImageType type;
38424         VkSampleCountFlagBits samples;
38425         VkImageUsageFlags usage;
38426         VkImageTiling tiling;
38427         PTR32 pPropertyCount;
38428         PTR32 pProperties;
38429     } *params = args;
38430
38431     TRACE("%#x, %#x, %#x, %#x, %#x, %#x, %#x, %#x\n", params->physicalDevice, params->format, params->type, params->samples, params->usage, params->tiling, params->pPropertyCount, params->pProperties);
38432
38433     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->format, params->type, params->samples, params->usage, params->tiling, (uint32_t *)UlongToPtr(params->pPropertyCount), (VkSparseImageFormatProperties *)UlongToPtr(params->pProperties));
38434     return STATUS_SUCCESS;
38435 }
38436
38437 #ifdef _WIN64
38438 static NTSTATUS thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2(void *args)
38439 {
38440     struct vkGetPhysicalDeviceSparseImageFormatProperties2_params *params = args;
38441
38442     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
38443
38444     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);
38445     return STATUS_SUCCESS;
38446 }
38447 #endif /* _WIN64 */
38448
38449 static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2(void *args)
38450 {
38451     struct
38452     {
38453         PTR32 physicalDevice;
38454         PTR32 pFormatInfo;
38455         PTR32 pPropertyCount;
38456         PTR32 pProperties;
38457     } *params = args;
38458     VkPhysicalDeviceSparseImageFormatInfo2 pFormatInfo_host;
38459     VkSparseImageFormatProperties2 *pProperties_host;
38460     struct conversion_context ctx;
38461
38462     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
38463
38464     init_conversion_context(&ctx);
38465     convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host((const VkPhysicalDeviceSparseImageFormatInfo232 *)UlongToPtr(params->pFormatInfo), &pFormatInfo_host);
38466     pProperties_host = convert_VkSparseImageFormatProperties2_array_win32_to_host(&ctx, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
38467     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pFormatInfo_host, (uint32_t *)UlongToPtr(params->pPropertyCount), pProperties_host);
38468     convert_VkSparseImageFormatProperties2_array_host_to_win32(pProperties_host, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
38469     free_conversion_context(&ctx);
38470     return STATUS_SUCCESS;
38471 }
38472
38473 #ifdef _WIN64
38474 static NTSTATUS thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(void *args)
38475 {
38476     struct vkGetPhysicalDeviceSparseImageFormatProperties2KHR_params *params = args;
38477
38478     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
38479
38480     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);
38481     return STATUS_SUCCESS;
38482 }
38483 #endif /* _WIN64 */
38484
38485 static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(void *args)
38486 {
38487     struct
38488     {
38489         PTR32 physicalDevice;
38490         PTR32 pFormatInfo;
38491         PTR32 pPropertyCount;
38492         PTR32 pProperties;
38493     } *params = args;
38494     VkPhysicalDeviceSparseImageFormatInfo2 pFormatInfo_host;
38495     VkSparseImageFormatProperties2 *pProperties_host;
38496     struct conversion_context ctx;
38497
38498     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
38499
38500     init_conversion_context(&ctx);
38501     convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host((const VkPhysicalDeviceSparseImageFormatInfo232 *)UlongToPtr(params->pFormatInfo), &pFormatInfo_host);
38502     pProperties_host = convert_VkSparseImageFormatProperties2_array_win32_to_host(&ctx, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
38503     wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pFormatInfo_host, (uint32_t *)UlongToPtr(params->pPropertyCount), pProperties_host);
38504     convert_VkSparseImageFormatProperties2_array_host_to_win32(pProperties_host, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
38505     free_conversion_context(&ctx);
38506     return STATUS_SUCCESS;
38507 }
38508
38509 #ifdef _WIN64
38510 static NTSTATUS thunk64_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(void *args)
38511 {
38512     struct vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_params *params = args;
38513
38514     TRACE("%p, %p, %p\n", params->physicalDevice, params->pCombinationCount, params->pCombinations);
38515
38516     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);
38517     return STATUS_SUCCESS;
38518 }
38519 #endif /* _WIN64 */
38520
38521 static NTSTATUS thunk32_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(void *args)
38522 {
38523     struct
38524     {
38525         PTR32 physicalDevice;
38526         PTR32 pCombinationCount;
38527         PTR32 pCombinations;
38528         VkResult result;
38529     } *params = args;
38530     VkFramebufferMixedSamplesCombinationNV *pCombinations_host;
38531     struct conversion_context ctx;
38532
38533     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pCombinationCount, params->pCombinations);
38534
38535     init_conversion_context(&ctx);
38536     pCombinations_host = convert_VkFramebufferMixedSamplesCombinationNV_array_win32_to_host(&ctx, (VkFramebufferMixedSamplesCombinationNV32 *)UlongToPtr(params->pCombinations), *(uint32_t *)UlongToPtr(params->pCombinationCount));
38537     params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (uint32_t *)UlongToPtr(params->pCombinationCount), pCombinations_host);
38538     convert_VkFramebufferMixedSamplesCombinationNV_array_host_to_win32(pCombinations_host, (VkFramebufferMixedSamplesCombinationNV32 *)UlongToPtr(params->pCombinations), *(uint32_t *)UlongToPtr(params->pCombinationCount));
38539     free_conversion_context(&ctx);
38540     return STATUS_SUCCESS;
38541 }
38542
38543 #ifdef _WIN64
38544 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceCapabilities2KHR(void *args)
38545 {
38546     struct vkGetPhysicalDeviceSurfaceCapabilities2KHR_params *params = args;
38547
38548     TRACE("%p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
38549
38550     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
38551     return STATUS_SUCCESS;
38552 }
38553 #endif /* _WIN64 */
38554
38555 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceCapabilities2KHR(void *args)
38556 {
38557     struct
38558     {
38559         PTR32 physicalDevice;
38560         PTR32 pSurfaceInfo;
38561         PTR32 pSurfaceCapabilities;
38562         VkResult result;
38563     } *params = args;
38564     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
38565     VkSurfaceCapabilities2KHR pSurfaceCapabilities_host;
38566     struct conversion_context ctx;
38567
38568     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
38569
38570     init_conversion_context(&ctx);
38571     convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_host(&ctx, (const VkPhysicalDeviceSurfaceInfo2KHR32 *)UlongToPtr(params->pSurfaceInfo), &pSurfaceInfo_host);
38572     convert_VkSurfaceCapabilities2KHR_win32_to_host(&ctx, (VkSurfaceCapabilities2KHR32 *)UlongToPtr(params->pSurfaceCapabilities), &pSurfaceCapabilities_host);
38573     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pSurfaceInfo_host, &pSurfaceCapabilities_host);
38574     convert_VkSurfaceCapabilities2KHR_host_to_win32(&pSurfaceCapabilities_host, (VkSurfaceCapabilities2KHR32 *)UlongToPtr(params->pSurfaceCapabilities));
38575     free_conversion_context(&ctx);
38576     return STATUS_SUCCESS;
38577 }
38578
38579 #ifdef _WIN64
38580 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(void *args)
38581 {
38582     struct vkGetPhysicalDeviceSurfaceCapabilitiesKHR_params *params = args;
38583
38584     TRACE("%p, 0x%s, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceCapabilities);
38585
38586     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(params->physicalDevice, params->surface, params->pSurfaceCapabilities);
38587     return STATUS_SUCCESS;
38588 }
38589 #endif /* _WIN64 */
38590
38591 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(void *args)
38592 {
38593     struct
38594     {
38595         PTR32 physicalDevice;
38596         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
38597         PTR32 pSurfaceCapabilities;
38598         VkResult result;
38599     } *params = args;
38600
38601     TRACE("%#x, 0x%s, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceCapabilities);
38602
38603     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), params->surface, (VkSurfaceCapabilitiesKHR *)UlongToPtr(params->pSurfaceCapabilities));
38604     return STATUS_SUCCESS;
38605 }
38606
38607 #ifdef _WIN64
38608 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceFormats2KHR(void *args)
38609 {
38610     struct vkGetPhysicalDeviceSurfaceFormats2KHR_params *params = args;
38611     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
38612
38613     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceFormatCount, params->pSurfaceFormats);
38614
38615     convert_VkPhysicalDeviceSurfaceInfo2KHR_win64_to_host(params->pSurfaceInfo, &pSurfaceInfo_host);
38616     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);
38617     return STATUS_SUCCESS;
38618 }
38619 #endif /* _WIN64 */
38620
38621 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceFormats2KHR(void *args)
38622 {
38623     struct
38624     {
38625         PTR32 physicalDevice;
38626         PTR32 pSurfaceInfo;
38627         PTR32 pSurfaceFormatCount;
38628         PTR32 pSurfaceFormats;
38629         VkResult result;
38630     } *params = args;
38631     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
38632     VkSurfaceFormat2KHR *pSurfaceFormats_host;
38633     struct conversion_context ctx;
38634
38635     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceFormatCount, params->pSurfaceFormats);
38636
38637     init_conversion_context(&ctx);
38638     convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_host(&ctx, (const VkPhysicalDeviceSurfaceInfo2KHR32 *)UlongToPtr(params->pSurfaceInfo), &pSurfaceInfo_host);
38639     pSurfaceFormats_host = convert_VkSurfaceFormat2KHR_array_win32_to_host(&ctx, (VkSurfaceFormat2KHR32 *)UlongToPtr(params->pSurfaceFormats), *(uint32_t *)UlongToPtr(params->pSurfaceFormatCount));
38640     params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormats2KHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pSurfaceInfo_host, (uint32_t *)UlongToPtr(params->pSurfaceFormatCount), pSurfaceFormats_host);
38641     convert_VkSurfaceFormat2KHR_array_host_to_win32(pSurfaceFormats_host, (VkSurfaceFormat2KHR32 *)UlongToPtr(params->pSurfaceFormats), *(uint32_t *)UlongToPtr(params->pSurfaceFormatCount));
38642     free_conversion_context(&ctx);
38643     return STATUS_SUCCESS;
38644 }
38645
38646 #ifdef _WIN64
38647 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceFormatsKHR(void *args)
38648 {
38649     struct vkGetPhysicalDeviceSurfaceFormatsKHR_params *params = args;
38650
38651     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceFormatCount, params->pSurfaceFormats);
38652
38653     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormatsKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->surface ? wine_surface_from_handle(params->surface)->driver_surface : 0, params->pSurfaceFormatCount, params->pSurfaceFormats);
38654     return STATUS_SUCCESS;
38655 }
38656 #endif /* _WIN64 */
38657
38658 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceFormatsKHR(void *args)
38659 {
38660     struct
38661     {
38662         PTR32 physicalDevice;
38663         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
38664         PTR32 pSurfaceFormatCount;
38665         PTR32 pSurfaceFormats;
38666         VkResult result;
38667     } *params = args;
38668
38669     TRACE("%#x, 0x%s, %#x, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceFormatCount, params->pSurfaceFormats);
38670
38671     params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormatsKHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->surface ? wine_surface_from_handle(params->surface)->driver_surface : 0, (uint32_t *)UlongToPtr(params->pSurfaceFormatCount), (VkSurfaceFormatKHR *)UlongToPtr(params->pSurfaceFormats));
38672     return STATUS_SUCCESS;
38673 }
38674
38675 #ifdef _WIN64
38676 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfacePresentModesKHR(void *args)
38677 {
38678     struct vkGetPhysicalDeviceSurfacePresentModesKHR_params *params = args;
38679
38680     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pPresentModeCount, params->pPresentModes);
38681
38682     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfacePresentModesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->surface ? wine_surface_from_handle(params->surface)->driver_surface : 0, params->pPresentModeCount, params->pPresentModes);
38683     return STATUS_SUCCESS;
38684 }
38685 #endif /* _WIN64 */
38686
38687 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfacePresentModesKHR(void *args)
38688 {
38689     struct
38690     {
38691         PTR32 physicalDevice;
38692         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
38693         PTR32 pPresentModeCount;
38694         PTR32 pPresentModes;
38695         VkResult result;
38696     } *params = args;
38697
38698     TRACE("%#x, 0x%s, %#x, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pPresentModeCount, params->pPresentModes);
38699
38700     params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceSurfacePresentModesKHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->surface ? wine_surface_from_handle(params->surface)->driver_surface : 0, (uint32_t *)UlongToPtr(params->pPresentModeCount), (VkPresentModeKHR *)UlongToPtr(params->pPresentModes));
38701     return STATUS_SUCCESS;
38702 }
38703
38704 #ifdef _WIN64
38705 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceSupportKHR(void *args)
38706 {
38707     struct vkGetPhysicalDeviceSurfaceSupportKHR_params *params = args;
38708
38709     TRACE("%p, %u, 0x%s, %p\n", params->physicalDevice, params->queueFamilyIndex, wine_dbgstr_longlong(params->surface), params->pSupported);
38710
38711     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);
38712     return STATUS_SUCCESS;
38713 }
38714 #endif /* _WIN64 */
38715
38716 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceSupportKHR(void *args)
38717 {
38718     struct
38719     {
38720         PTR32 physicalDevice;
38721         uint32_t queueFamilyIndex;
38722         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
38723         PTR32 pSupported;
38724         VkResult result;
38725     } *params = args;
38726
38727     TRACE("%#x, %u, 0x%s, %#x\n", params->physicalDevice, params->queueFamilyIndex, wine_dbgstr_longlong(params->surface), params->pSupported);
38728
38729     params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceSurfaceSupportKHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->queueFamilyIndex, wine_surface_from_handle(params->surface)->driver_surface, (VkBool32 *)UlongToPtr(params->pSupported));
38730     return STATUS_SUCCESS;
38731 }
38732
38733 #ifdef _WIN64
38734 static NTSTATUS thunk64_vkGetPhysicalDeviceToolProperties(void *args)
38735 {
38736     struct vkGetPhysicalDeviceToolProperties_params *params = args;
38737
38738     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
38739
38740     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);
38741     return STATUS_SUCCESS;
38742 }
38743 #endif /* _WIN64 */
38744
38745 static NTSTATUS thunk32_vkGetPhysicalDeviceToolProperties(void *args)
38746 {
38747     struct
38748     {
38749         PTR32 physicalDevice;
38750         PTR32 pToolCount;
38751         PTR32 pToolProperties;
38752         VkResult result;
38753     } *params = args;
38754     VkPhysicalDeviceToolProperties *pToolProperties_host;
38755     struct conversion_context ctx;
38756
38757     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
38758
38759     init_conversion_context(&ctx);
38760     pToolProperties_host = convert_VkPhysicalDeviceToolProperties_array_win32_to_host(&ctx, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
38761     params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceToolProperties(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (uint32_t *)UlongToPtr(params->pToolCount), pToolProperties_host);
38762     convert_VkPhysicalDeviceToolProperties_array_host_to_win32(pToolProperties_host, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
38763     free_conversion_context(&ctx);
38764     return STATUS_SUCCESS;
38765 }
38766
38767 #ifdef _WIN64
38768 static NTSTATUS thunk64_vkGetPhysicalDeviceToolPropertiesEXT(void *args)
38769 {
38770     struct vkGetPhysicalDeviceToolPropertiesEXT_params *params = args;
38771
38772     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
38773
38774     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);
38775     return STATUS_SUCCESS;
38776 }
38777 #endif /* _WIN64 */
38778
38779 static NTSTATUS thunk32_vkGetPhysicalDeviceToolPropertiesEXT(void *args)
38780 {
38781     struct
38782     {
38783         PTR32 physicalDevice;
38784         PTR32 pToolCount;
38785         PTR32 pToolProperties;
38786         VkResult result;
38787     } *params = args;
38788     VkPhysicalDeviceToolProperties *pToolProperties_host;
38789     struct conversion_context ctx;
38790
38791     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
38792
38793     init_conversion_context(&ctx);
38794     pToolProperties_host = convert_VkPhysicalDeviceToolProperties_array_win32_to_host(&ctx, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
38795     params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceToolPropertiesEXT(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (uint32_t *)UlongToPtr(params->pToolCount), pToolProperties_host);
38796     convert_VkPhysicalDeviceToolProperties_array_host_to_win32(pToolProperties_host, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
38797     free_conversion_context(&ctx);
38798     return STATUS_SUCCESS;
38799 }
38800
38801 #ifdef _WIN64
38802 static NTSTATUS thunk64_vkGetPhysicalDeviceWin32PresentationSupportKHR(void *args)
38803 {
38804     struct vkGetPhysicalDeviceWin32PresentationSupportKHR_params *params = args;
38805
38806     TRACE("%p, %u\n", params->physicalDevice, params->queueFamilyIndex);
38807
38808     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex);
38809     return STATUS_SUCCESS;
38810 }
38811 #endif /* _WIN64 */
38812
38813 static NTSTATUS thunk32_vkGetPhysicalDeviceWin32PresentationSupportKHR(void *args)
38814 {
38815     struct
38816     {
38817         PTR32 physicalDevice;
38818         uint32_t queueFamilyIndex;
38819         VkBool32 result;
38820     } *params = args;
38821
38822     TRACE("%#x, %u\n", params->physicalDevice, params->queueFamilyIndex);
38823
38824     params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->queueFamilyIndex);
38825     return STATUS_SUCCESS;
38826 }
38827
38828 #ifdef _WIN64
38829 static NTSTATUS thunk64_vkGetPipelineCacheData(void *args)
38830 {
38831     struct vkGetPipelineCacheData_params *params = args;
38832
38833     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pDataSize, params->pData);
38834
38835     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineCacheData(wine_device_from_handle(params->device)->device, params->pipelineCache, params->pDataSize, params->pData);
38836     return STATUS_SUCCESS;
38837 }
38838 #endif /* _WIN64 */
38839
38840 static NTSTATUS thunk32_vkGetPipelineCacheData(void *args)
38841 {
38842     struct
38843     {
38844         PTR32 device;
38845         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
38846         PTR32 pDataSize;
38847         PTR32 pData;
38848         VkResult result;
38849     } *params = args;
38850     size_t pDataSize_host;
38851
38852     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pDataSize, params->pData);
38853
38854     pDataSize_host = *(PTR32 *)UlongToPtr(params->pDataSize);
38855     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPipelineCacheData(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipelineCache, &pDataSize_host, (void *)UlongToPtr(params->pData));
38856     *(PTR32 *)UlongToPtr(params->pDataSize) = pDataSize_host;
38857     return STATUS_SUCCESS;
38858 }
38859
38860 #ifdef _WIN64
38861 static NTSTATUS thunk64_vkGetPipelineExecutableInternalRepresentationsKHR(void *args)
38862 {
38863     struct vkGetPipelineExecutableInternalRepresentationsKHR_params *params = args;
38864
38865     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
38866
38867     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableInternalRepresentationsKHR(wine_device_from_handle(params->device)->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
38868     return STATUS_SUCCESS;
38869 }
38870 #endif /* _WIN64 */
38871
38872 static NTSTATUS thunk32_vkGetPipelineExecutableInternalRepresentationsKHR(void *args)
38873 {
38874     struct
38875     {
38876         PTR32 device;
38877         PTR32 pExecutableInfo;
38878         PTR32 pInternalRepresentationCount;
38879         PTR32 pInternalRepresentations;
38880         VkResult result;
38881     } *params = args;
38882     VkPipelineExecutableInfoKHR pExecutableInfo_host;
38883     VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations_host;
38884     struct conversion_context ctx;
38885
38886     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
38887
38888     init_conversion_context(&ctx);
38889     convert_VkPipelineExecutableInfoKHR_win32_to_host((const VkPipelineExecutableInfoKHR32 *)UlongToPtr(params->pExecutableInfo), &pExecutableInfo_host);
38890     pInternalRepresentations_host = convert_VkPipelineExecutableInternalRepresentationKHR_array_win32_to_host(&ctx, (VkPipelineExecutableInternalRepresentationKHR32 *)UlongToPtr(params->pInternalRepresentations), *(uint32_t *)UlongToPtr(params->pInternalRepresentationCount));
38891     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPipelineExecutableInternalRepresentationsKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pExecutableInfo_host, (uint32_t *)UlongToPtr(params->pInternalRepresentationCount), pInternalRepresentations_host);
38892     convert_VkPipelineExecutableInternalRepresentationKHR_array_host_to_win32(pInternalRepresentations_host, (VkPipelineExecutableInternalRepresentationKHR32 *)UlongToPtr(params->pInternalRepresentations), *(uint32_t *)UlongToPtr(params->pInternalRepresentationCount));
38893     free_conversion_context(&ctx);
38894     return STATUS_SUCCESS;
38895 }
38896
38897 #ifdef _WIN64
38898 static NTSTATUS thunk64_vkGetPipelineExecutablePropertiesKHR(void *args)
38899 {
38900     struct vkGetPipelineExecutablePropertiesKHR_params *params = args;
38901
38902     TRACE("%p, %p, %p, %p\n", params->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
38903
38904     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutablePropertiesKHR(wine_device_from_handle(params->device)->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
38905     return STATUS_SUCCESS;
38906 }
38907 #endif /* _WIN64 */
38908
38909 static NTSTATUS thunk32_vkGetPipelineExecutablePropertiesKHR(void *args)
38910 {
38911     struct
38912     {
38913         PTR32 device;
38914         PTR32 pPipelineInfo;
38915         PTR32 pExecutableCount;
38916         PTR32 pProperties;
38917         VkResult result;
38918     } *params = args;
38919     VkPipelineInfoKHR pPipelineInfo_host;
38920     VkPipelineExecutablePropertiesKHR *pProperties_host;
38921     struct conversion_context ctx;
38922
38923     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
38924
38925     init_conversion_context(&ctx);
38926     convert_VkPipelineInfoKHR_win32_to_host((const VkPipelineInfoKHR32 *)UlongToPtr(params->pPipelineInfo), &pPipelineInfo_host);
38927     pProperties_host = convert_VkPipelineExecutablePropertiesKHR_array_win32_to_host(&ctx, (VkPipelineExecutablePropertiesKHR32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pExecutableCount));
38928     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPipelineExecutablePropertiesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pPipelineInfo_host, (uint32_t *)UlongToPtr(params->pExecutableCount), pProperties_host);
38929     convert_VkPipelineExecutablePropertiesKHR_array_host_to_win32(pProperties_host, (VkPipelineExecutablePropertiesKHR32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pExecutableCount));
38930     free_conversion_context(&ctx);
38931     return STATUS_SUCCESS;
38932 }
38933
38934 #ifdef _WIN64
38935 static NTSTATUS thunk64_vkGetPipelineExecutableStatisticsKHR(void *args)
38936 {
38937     struct vkGetPipelineExecutableStatisticsKHR_params *params = args;
38938
38939     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
38940
38941     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableStatisticsKHR(wine_device_from_handle(params->device)->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
38942     return STATUS_SUCCESS;
38943 }
38944 #endif /* _WIN64 */
38945
38946 static NTSTATUS thunk32_vkGetPipelineExecutableStatisticsKHR(void *args)
38947 {
38948     struct
38949     {
38950         PTR32 device;
38951         PTR32 pExecutableInfo;
38952         PTR32 pStatisticCount;
38953         PTR32 pStatistics;
38954         VkResult result;
38955     } *params = args;
38956     VkPipelineExecutableInfoKHR pExecutableInfo_host;
38957     VkPipelineExecutableStatisticKHR *pStatistics_host;
38958     struct conversion_context ctx;
38959
38960     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
38961
38962     init_conversion_context(&ctx);
38963     convert_VkPipelineExecutableInfoKHR_win32_to_host((const VkPipelineExecutableInfoKHR32 *)UlongToPtr(params->pExecutableInfo), &pExecutableInfo_host);
38964     pStatistics_host = convert_VkPipelineExecutableStatisticKHR_array_win32_to_host(&ctx, (VkPipelineExecutableStatisticKHR32 *)UlongToPtr(params->pStatistics), *(uint32_t *)UlongToPtr(params->pStatisticCount));
38965     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPipelineExecutableStatisticsKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pExecutableInfo_host, (uint32_t *)UlongToPtr(params->pStatisticCount), pStatistics_host);
38966     convert_VkPipelineExecutableStatisticKHR_array_host_to_win32(pStatistics_host, (VkPipelineExecutableStatisticKHR32 *)UlongToPtr(params->pStatistics), *(uint32_t *)UlongToPtr(params->pStatisticCount));
38967     free_conversion_context(&ctx);
38968     return STATUS_SUCCESS;
38969 }
38970
38971 #ifdef _WIN64
38972 static NTSTATUS thunk64_vkGetPipelinePropertiesEXT(void *args)
38973 {
38974     struct vkGetPipelinePropertiesEXT_params *params = args;
38975
38976     TRACE("%p, %p, %p\n", params->device, params->pPipelineInfo, params->pPipelineProperties);
38977
38978     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelinePropertiesEXT(wine_device_from_handle(params->device)->device, params->pPipelineInfo, params->pPipelineProperties);
38979     return STATUS_SUCCESS;
38980 }
38981 #endif /* _WIN64 */
38982
38983 static NTSTATUS thunk32_vkGetPipelinePropertiesEXT(void *args)
38984 {
38985     struct
38986     {
38987         PTR32 device;
38988         PTR32 pPipelineInfo;
38989         PTR32 pPipelineProperties;
38990         VkResult result;
38991     } *params = args;
38992     VkPipelineInfoEXT pPipelineInfo_host;
38993
38994     TRACE("%#x, %#x, %#x\n", params->device, params->pPipelineInfo, params->pPipelineProperties);
38995
38996     convert_VkPipelineInfoEXT_win32_to_host((const VkPipelineInfoEXT32 *)UlongToPtr(params->pPipelineInfo), &pPipelineInfo_host);
38997     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPipelinePropertiesEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pPipelineInfo_host, (VkBaseOutStructure *)UlongToPtr(params->pPipelineProperties));
38998     return STATUS_SUCCESS;
38999 }
39000
39001 #ifdef _WIN64
39002 static NTSTATUS thunk64_vkGetPrivateData(void *args)
39003 {
39004     struct vkGetPrivateData_params *params = args;
39005
39006     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);
39007
39008     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);
39009     return STATUS_SUCCESS;
39010 }
39011 #endif /* _WIN64 */
39012
39013 static NTSTATUS thunk32_vkGetPrivateData(void *args)
39014 {
39015     struct
39016     {
39017         PTR32 device;
39018         VkObjectType objectType;
39019         uint64_t DECLSPEC_ALIGN(8) objectHandle;
39020         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
39021         PTR32 pData;
39022     } *params = args;
39023
39024     TRACE("%#x, %#x, 0x%s, 0x%s, %#x\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), params->pData);
39025
39026     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPrivateData(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, (uint64_t *)UlongToPtr(params->pData));
39027     return STATUS_SUCCESS;
39028 }
39029
39030 #ifdef _WIN64
39031 static NTSTATUS thunk64_vkGetPrivateDataEXT(void *args)
39032 {
39033     struct vkGetPrivateDataEXT_params *params = args;
39034
39035     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);
39036
39037     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);
39038     return STATUS_SUCCESS;
39039 }
39040 #endif /* _WIN64 */
39041
39042 static NTSTATUS thunk32_vkGetPrivateDataEXT(void *args)
39043 {
39044     struct
39045     {
39046         PTR32 device;
39047         VkObjectType objectType;
39048         uint64_t DECLSPEC_ALIGN(8) objectHandle;
39049         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
39050         PTR32 pData;
39051     } *params = args;
39052
39053     TRACE("%#x, %#x, 0x%s, 0x%s, %#x\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), params->pData);
39054
39055     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPrivateDataEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, (uint64_t *)UlongToPtr(params->pData));
39056     return STATUS_SUCCESS;
39057 }
39058
39059 #ifdef _WIN64
39060 static NTSTATUS thunk64_vkGetQueryPoolResults(void *args)
39061 {
39062     struct vkGetQueryPoolResults_params *params = args;
39063
39064     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);
39065
39066     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);
39067     return STATUS_SUCCESS;
39068 }
39069 #endif /* _WIN64 */
39070
39071 static NTSTATUS thunk32_vkGetQueryPoolResults(void *args)
39072 {
39073     struct
39074     {
39075         PTR32 device;
39076         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
39077         uint32_t firstQuery;
39078         uint32_t queryCount;
39079         PTR32 dataSize;
39080         PTR32 pData;
39081         VkDeviceSize DECLSPEC_ALIGN(8) stride;
39082         VkQueryResultFlags flags;
39083         VkResult result;
39084     } *params = args;
39085
39086     TRACE("%#x, 0x%s, %u, %u, 0x%s, %#x, 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);
39087
39088     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetQueryPoolResults(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->queryPool, params->firstQuery, params->queryCount, params->dataSize, (void *)UlongToPtr(params->pData), params->stride, params->flags);
39089     return STATUS_SUCCESS;
39090 }
39091
39092 #ifdef _WIN64
39093 static NTSTATUS thunk64_vkGetQueueCheckpointData2NV(void *args)
39094 {
39095     struct vkGetQueueCheckpointData2NV_params *params = args;
39096
39097     TRACE("%p, %p, %p\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
39098
39099     wine_queue_from_handle(params->queue)->device->funcs.p_vkGetQueueCheckpointData2NV(wine_queue_from_handle(params->queue)->queue, params->pCheckpointDataCount, params->pCheckpointData);
39100     return STATUS_SUCCESS;
39101 }
39102 #endif /* _WIN64 */
39103
39104 static NTSTATUS thunk32_vkGetQueueCheckpointData2NV(void *args)
39105 {
39106     struct
39107     {
39108         PTR32 queue;
39109         PTR32 pCheckpointDataCount;
39110         PTR32 pCheckpointData;
39111     } *params = args;
39112     VkCheckpointData2NV *pCheckpointData_host;
39113     struct conversion_context ctx;
39114
39115     TRACE("%#x, %#x, %#x\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
39116
39117     init_conversion_context(&ctx);
39118     pCheckpointData_host = convert_VkCheckpointData2NV_array_win32_to_host(&ctx, (VkCheckpointData2NV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
39119     wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkGetQueueCheckpointData2NV(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, (uint32_t *)UlongToPtr(params->pCheckpointDataCount), pCheckpointData_host);
39120     convert_VkCheckpointData2NV_array_host_to_win32(pCheckpointData_host, (VkCheckpointData2NV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
39121     free_conversion_context(&ctx);
39122     return STATUS_SUCCESS;
39123 }
39124
39125 #ifdef _WIN64
39126 static NTSTATUS thunk64_vkGetQueueCheckpointDataNV(void *args)
39127 {
39128     struct vkGetQueueCheckpointDataNV_params *params = args;
39129
39130     TRACE("%p, %p, %p\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
39131
39132     wine_queue_from_handle(params->queue)->device->funcs.p_vkGetQueueCheckpointDataNV(wine_queue_from_handle(params->queue)->queue, params->pCheckpointDataCount, params->pCheckpointData);
39133     return STATUS_SUCCESS;
39134 }
39135 #endif /* _WIN64 */
39136
39137 static NTSTATUS thunk32_vkGetQueueCheckpointDataNV(void *args)
39138 {
39139     struct
39140     {
39141         PTR32 queue;
39142         PTR32 pCheckpointDataCount;
39143         PTR32 pCheckpointData;
39144     } *params = args;
39145     VkCheckpointDataNV *pCheckpointData_host;
39146     struct conversion_context ctx;
39147
39148     TRACE("%#x, %#x, %#x\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
39149
39150     init_conversion_context(&ctx);
39151     pCheckpointData_host = convert_VkCheckpointDataNV_array_win32_to_host(&ctx, (VkCheckpointDataNV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
39152     wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkGetQueueCheckpointDataNV(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, (uint32_t *)UlongToPtr(params->pCheckpointDataCount), pCheckpointData_host);
39153     convert_VkCheckpointDataNV_array_host_to_win32(pCheckpointData_host, (VkCheckpointDataNV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
39154     free_conversion_context(&ctx);
39155     return STATUS_SUCCESS;
39156 }
39157
39158 #ifdef _WIN64
39159 static NTSTATUS thunk64_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(void *args)
39160 {
39161     struct vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_params *params = args;
39162
39163     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);
39164
39165     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);
39166     return STATUS_SUCCESS;
39167 }
39168 #endif /* _WIN64 */
39169
39170 static NTSTATUS thunk32_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(void *args)
39171 {
39172     struct
39173     {
39174         PTR32 device;
39175         VkPipeline DECLSPEC_ALIGN(8) pipeline;
39176         uint32_t firstGroup;
39177         uint32_t groupCount;
39178         PTR32 dataSize;
39179         PTR32 pData;
39180         VkResult result;
39181     } *params = args;
39182
39183     TRACE("%#x, 0x%s, %u, %u, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);
39184
39185     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, (void *)UlongToPtr(params->pData));
39186     return STATUS_SUCCESS;
39187 }
39188
39189 #ifdef _WIN64
39190 static NTSTATUS thunk64_vkGetRayTracingShaderGroupHandlesKHR(void *args)
39191 {
39192     struct vkGetRayTracingShaderGroupHandlesKHR_params *params = args;
39193
39194     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);
39195
39196     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);
39197     return STATUS_SUCCESS;
39198 }
39199 #endif /* _WIN64 */
39200
39201 static NTSTATUS thunk32_vkGetRayTracingShaderGroupHandlesKHR(void *args)
39202 {
39203     struct
39204     {
39205         PTR32 device;
39206         VkPipeline DECLSPEC_ALIGN(8) pipeline;
39207         uint32_t firstGroup;
39208         uint32_t groupCount;
39209         PTR32 dataSize;
39210         PTR32 pData;
39211         VkResult result;
39212     } *params = args;
39213
39214     TRACE("%#x, 0x%s, %u, %u, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);
39215
39216     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetRayTracingShaderGroupHandlesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, (void *)UlongToPtr(params->pData));
39217     return STATUS_SUCCESS;
39218 }
39219
39220 #ifdef _WIN64
39221 static NTSTATUS thunk64_vkGetRayTracingShaderGroupHandlesNV(void *args)
39222 {
39223     struct vkGetRayTracingShaderGroupHandlesNV_params *params = args;
39224
39225     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);
39226
39227     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);
39228     return STATUS_SUCCESS;
39229 }
39230 #endif /* _WIN64 */
39231
39232 static NTSTATUS thunk32_vkGetRayTracingShaderGroupHandlesNV(void *args)
39233 {
39234     struct
39235     {
39236         PTR32 device;
39237         VkPipeline DECLSPEC_ALIGN(8) pipeline;
39238         uint32_t firstGroup;
39239         uint32_t groupCount;
39240         PTR32 dataSize;
39241         PTR32 pData;
39242         VkResult result;
39243     } *params = args;
39244
39245     TRACE("%#x, 0x%s, %u, %u, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);
39246
39247     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetRayTracingShaderGroupHandlesNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, (void *)UlongToPtr(params->pData));
39248     return STATUS_SUCCESS;
39249 }
39250
39251 #ifdef _WIN64
39252 static NTSTATUS thunk64_vkGetRayTracingShaderGroupStackSizeKHR(void *args)
39253 {
39254     struct vkGetRayTracingShaderGroupStackSizeKHR_params *params = args;
39255
39256     TRACE("%p, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->group, params->groupShader);
39257
39258     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupStackSizeKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->group, params->groupShader);
39259     return STATUS_SUCCESS;
39260 }
39261 #endif /* _WIN64 */
39262
39263 static NTSTATUS thunk32_vkGetRayTracingShaderGroupStackSizeKHR(void *args)
39264 {
39265     struct
39266     {
39267         PTR32 device;
39268         VkPipeline DECLSPEC_ALIGN(8) pipeline;
39269         uint32_t group;
39270         VkShaderGroupShaderKHR groupShader;
39271         VkDeviceSize result;
39272     } *params = args;
39273
39274     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->group, params->groupShader);
39275
39276     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetRayTracingShaderGroupStackSizeKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipeline, params->group, params->groupShader);
39277     return STATUS_SUCCESS;
39278 }
39279
39280 #ifdef _WIN64
39281 static NTSTATUS thunk64_vkGetRenderAreaGranularity(void *args)
39282 {
39283     struct vkGetRenderAreaGranularity_params *params = args;
39284
39285     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pGranularity);
39286
39287     wine_device_from_handle(params->device)->funcs.p_vkGetRenderAreaGranularity(wine_device_from_handle(params->device)->device, params->renderPass, params->pGranularity);
39288     return STATUS_SUCCESS;
39289 }
39290 #endif /* _WIN64 */
39291
39292 static NTSTATUS thunk32_vkGetRenderAreaGranularity(void *args)
39293 {
39294     struct
39295     {
39296         PTR32 device;
39297         VkRenderPass DECLSPEC_ALIGN(8) renderPass;
39298         PTR32 pGranularity;
39299     } *params = args;
39300
39301     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pGranularity);
39302
39303     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetRenderAreaGranularity(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->renderPass, (VkExtent2D *)UlongToPtr(params->pGranularity));
39304     return STATUS_SUCCESS;
39305 }
39306
39307 #ifdef _WIN64
39308 static NTSTATUS thunk64_vkGetSamplerOpaqueCaptureDescriptorDataEXT(void *args)
39309 {
39310     struct vkGetSamplerOpaqueCaptureDescriptorDataEXT_params *params = args;
39311
39312     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
39313
39314     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSamplerOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
39315     return STATUS_SUCCESS;
39316 }
39317 #endif /* _WIN64 */
39318
39319 static NTSTATUS thunk32_vkGetSamplerOpaqueCaptureDescriptorDataEXT(void *args)
39320 {
39321     struct
39322     {
39323         PTR32 device;
39324         PTR32 pInfo;
39325         PTR32 pData;
39326         VkResult result;
39327     } *params = args;
39328     VkSamplerCaptureDescriptorDataInfoEXT pInfo_host;
39329
39330     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
39331
39332     convert_VkSamplerCaptureDescriptorDataInfoEXT_win32_to_host((const VkSamplerCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
39333     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetSamplerOpaqueCaptureDescriptorDataEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, (void *)UlongToPtr(params->pData));
39334     return STATUS_SUCCESS;
39335 }
39336
39337 #ifdef _WIN64
39338 static NTSTATUS thunk64_vkGetSemaphoreCounterValue(void *args)
39339 {
39340     struct vkGetSemaphoreCounterValue_params *params = args;
39341
39342     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
39343
39344     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValue(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
39345     return STATUS_SUCCESS;
39346 }
39347 #endif /* _WIN64 */
39348
39349 static NTSTATUS thunk32_vkGetSemaphoreCounterValue(void *args)
39350 {
39351     struct
39352     {
39353         PTR32 device;
39354         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
39355         PTR32 pValue;
39356         VkResult result;
39357     } *params = args;
39358
39359     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
39360
39361     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetSemaphoreCounterValue(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->semaphore, (uint64_t *)UlongToPtr(params->pValue));
39362     return STATUS_SUCCESS;
39363 }
39364
39365 #ifdef _WIN64
39366 static NTSTATUS thunk64_vkGetSemaphoreCounterValueKHR(void *args)
39367 {
39368     struct vkGetSemaphoreCounterValueKHR_params *params = args;
39369
39370     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
39371
39372     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValueKHR(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
39373     return STATUS_SUCCESS;
39374 }
39375 #endif /* _WIN64 */
39376
39377 static NTSTATUS thunk32_vkGetSemaphoreCounterValueKHR(void *args)
39378 {
39379     struct
39380     {
39381         PTR32 device;
39382         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
39383         PTR32 pValue;
39384         VkResult result;
39385     } *params = args;
39386
39387     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
39388
39389     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetSemaphoreCounterValueKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->semaphore, (uint64_t *)UlongToPtr(params->pValue));
39390     return STATUS_SUCCESS;
39391 }
39392
39393 #ifdef _WIN64
39394 static NTSTATUS thunk64_vkGetShaderBinaryDataEXT(void *args)
39395 {
39396     struct vkGetShaderBinaryDataEXT_params *params = args;
39397
39398     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->shader), params->pDataSize, params->pData);
39399
39400     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetShaderBinaryDataEXT(wine_device_from_handle(params->device)->device, params->shader, params->pDataSize, params->pData);
39401     return STATUS_SUCCESS;
39402 }
39403 #endif /* _WIN64 */
39404
39405 static NTSTATUS thunk32_vkGetShaderBinaryDataEXT(void *args)
39406 {
39407     struct
39408     {
39409         PTR32 device;
39410         VkShaderEXT DECLSPEC_ALIGN(8) shader;
39411         PTR32 pDataSize;
39412         PTR32 pData;
39413         VkResult result;
39414     } *params = args;
39415     size_t pDataSize_host;
39416
39417     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->shader), params->pDataSize, params->pData);
39418
39419     pDataSize_host = *(PTR32 *)UlongToPtr(params->pDataSize);
39420     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetShaderBinaryDataEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->shader, &pDataSize_host, (void *)UlongToPtr(params->pData));
39421     *(PTR32 *)UlongToPtr(params->pDataSize) = pDataSize_host;
39422     return STATUS_SUCCESS;
39423 }
39424
39425 #ifdef _WIN64
39426 static NTSTATUS thunk64_vkGetShaderInfoAMD(void *args)
39427 {
39428     struct vkGetShaderInfoAMD_params *params = args;
39429
39430     TRACE("%p, 0x%s, %#x, %#x, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);
39431
39432     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);
39433     return STATUS_SUCCESS;
39434 }
39435 #endif /* _WIN64 */
39436
39437 static NTSTATUS thunk32_vkGetShaderInfoAMD(void *args)
39438 {
39439     struct
39440     {
39441         PTR32 device;
39442         VkPipeline DECLSPEC_ALIGN(8) pipeline;
39443         VkShaderStageFlagBits shaderStage;
39444         VkShaderInfoTypeAMD infoType;
39445         PTR32 pInfoSize;
39446         PTR32 pInfo;
39447         VkResult result;
39448     } *params = args;
39449     size_t pInfoSize_host;
39450
39451     TRACE("%#x, 0x%s, %#x, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);
39452
39453     pInfoSize_host = *(PTR32 *)UlongToPtr(params->pInfoSize);
39454     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetShaderInfoAMD(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipeline, params->shaderStage, params->infoType, &pInfoSize_host, (void *)UlongToPtr(params->pInfo));
39455     *(PTR32 *)UlongToPtr(params->pInfoSize) = pInfoSize_host;
39456     return STATUS_SUCCESS;
39457 }
39458
39459 #ifdef _WIN64
39460 static NTSTATUS thunk64_vkGetShaderModuleCreateInfoIdentifierEXT(void *args)
39461 {
39462     struct vkGetShaderModuleCreateInfoIdentifierEXT_params *params = args;
39463
39464     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pIdentifier);
39465
39466     wine_device_from_handle(params->device)->funcs.p_vkGetShaderModuleCreateInfoIdentifierEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pIdentifier);
39467     return STATUS_SUCCESS;
39468 }
39469 #endif /* _WIN64 */
39470
39471 static NTSTATUS thunk32_vkGetShaderModuleCreateInfoIdentifierEXT(void *args)
39472 {
39473     struct
39474     {
39475         PTR32 device;
39476         PTR32 pCreateInfo;
39477         PTR32 pIdentifier;
39478     } *params = args;
39479     VkShaderModuleCreateInfo pCreateInfo_host;
39480     VkShaderModuleIdentifierEXT pIdentifier_host;
39481     struct conversion_context ctx;
39482
39483     TRACE("%#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pIdentifier);
39484
39485     init_conversion_context(&ctx);
39486     convert_VkShaderModuleCreateInfo_win32_to_host(&ctx, (const VkShaderModuleCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
39487     convert_VkShaderModuleIdentifierEXT_win32_to_host((VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier), &pIdentifier_host);
39488     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetShaderModuleCreateInfoIdentifierEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, &pIdentifier_host);
39489     convert_VkShaderModuleIdentifierEXT_host_to_win32(&pIdentifier_host, (VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier));
39490     free_conversion_context(&ctx);
39491     return STATUS_SUCCESS;
39492 }
39493
39494 #ifdef _WIN64
39495 static NTSTATUS thunk64_vkGetShaderModuleIdentifierEXT(void *args)
39496 {
39497     struct vkGetShaderModuleIdentifierEXT_params *params = args;
39498
39499     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pIdentifier);
39500
39501     wine_device_from_handle(params->device)->funcs.p_vkGetShaderModuleIdentifierEXT(wine_device_from_handle(params->device)->device, params->shaderModule, params->pIdentifier);
39502     return STATUS_SUCCESS;
39503 }
39504 #endif /* _WIN64 */
39505
39506 static NTSTATUS thunk32_vkGetShaderModuleIdentifierEXT(void *args)
39507 {
39508     struct
39509     {
39510         PTR32 device;
39511         VkShaderModule DECLSPEC_ALIGN(8) shaderModule;
39512         PTR32 pIdentifier;
39513     } *params = args;
39514     VkShaderModuleIdentifierEXT pIdentifier_host;
39515
39516     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pIdentifier);
39517
39518     convert_VkShaderModuleIdentifierEXT_win32_to_host((VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier), &pIdentifier_host);
39519     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetShaderModuleIdentifierEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->shaderModule, &pIdentifier_host);
39520     convert_VkShaderModuleIdentifierEXT_host_to_win32(&pIdentifier_host, (VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier));
39521     return STATUS_SUCCESS;
39522 }
39523
39524 #ifdef _WIN64
39525 static NTSTATUS thunk64_vkGetSwapchainImagesKHR(void *args)
39526 {
39527     struct vkGetSwapchainImagesKHR_params *params = args;
39528
39529     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainImageCount, params->pSwapchainImages);
39530
39531     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSwapchainImagesKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->pSwapchainImageCount, params->pSwapchainImages);
39532     return STATUS_SUCCESS;
39533 }
39534 #endif /* _WIN64 */
39535
39536 static NTSTATUS thunk32_vkGetSwapchainImagesKHR(void *args)
39537 {
39538     struct
39539     {
39540         PTR32 device;
39541         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
39542         PTR32 pSwapchainImageCount;
39543         PTR32 pSwapchainImages;
39544         VkResult result;
39545     } *params = args;
39546
39547     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainImageCount, params->pSwapchainImages);
39548
39549     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetSwapchainImagesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->swapchain, (uint32_t *)UlongToPtr(params->pSwapchainImageCount), (VkImage *)UlongToPtr(params->pSwapchainImages));
39550     return STATUS_SUCCESS;
39551 }
39552
39553 #ifdef _WIN64
39554 static NTSTATUS thunk64_vkGetValidationCacheDataEXT(void *args)
39555 {
39556     struct vkGetValidationCacheDataEXT_params *params = args;
39557
39558     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pDataSize, params->pData);
39559
39560     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetValidationCacheDataEXT(wine_device_from_handle(params->device)->device, params->validationCache, params->pDataSize, params->pData);
39561     return STATUS_SUCCESS;
39562 }
39563 #endif /* _WIN64 */
39564
39565 static NTSTATUS thunk32_vkGetValidationCacheDataEXT(void *args)
39566 {
39567     struct
39568     {
39569         PTR32 device;
39570         VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
39571         PTR32 pDataSize;
39572         PTR32 pData;
39573         VkResult result;
39574     } *params = args;
39575     size_t pDataSize_host;
39576
39577     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pDataSize, params->pData);
39578
39579     pDataSize_host = *(PTR32 *)UlongToPtr(params->pDataSize);
39580     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetValidationCacheDataEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->validationCache, &pDataSize_host, (void *)UlongToPtr(params->pData));
39581     *(PTR32 *)UlongToPtr(params->pDataSize) = pDataSize_host;
39582     return STATUS_SUCCESS;
39583 }
39584
39585 #ifdef _WIN64
39586 static NTSTATUS thunk64_vkInitializePerformanceApiINTEL(void *args)
39587 {
39588     struct vkInitializePerformanceApiINTEL_params *params = args;
39589
39590     TRACE("%p, %p\n", params->device, params->pInitializeInfo);
39591
39592     params->result = wine_device_from_handle(params->device)->funcs.p_vkInitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device, params->pInitializeInfo);
39593     return STATUS_SUCCESS;
39594 }
39595 #endif /* _WIN64 */
39596
39597 static NTSTATUS thunk32_vkInitializePerformanceApiINTEL(void *args)
39598 {
39599     struct
39600     {
39601         PTR32 device;
39602         PTR32 pInitializeInfo;
39603         VkResult result;
39604     } *params = args;
39605     VkInitializePerformanceApiInfoINTEL pInitializeInfo_host;
39606
39607     TRACE("%#x, %#x\n", params->device, params->pInitializeInfo);
39608
39609     convert_VkInitializePerformanceApiInfoINTEL_win32_to_host((const VkInitializePerformanceApiInfoINTEL32 *)UlongToPtr(params->pInitializeInfo), &pInitializeInfo_host);
39610     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkInitializePerformanceApiINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInitializeInfo_host);
39611     return STATUS_SUCCESS;
39612 }
39613
39614 #ifdef _WIN64
39615 static NTSTATUS thunk64_vkInvalidateMappedMemoryRanges(void *args)
39616 {
39617     struct vkInvalidateMappedMemoryRanges_params *params = args;
39618     const VkMappedMemoryRange *pMemoryRanges_host;
39619     struct conversion_context ctx;
39620
39621     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
39622
39623     init_conversion_context(&ctx);
39624     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win64_to_host(&ctx, params->pMemoryRanges, params->memoryRangeCount);
39625     params->result = wine_device_from_handle(params->device)->funcs.p_vkInvalidateMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, pMemoryRanges_host);
39626     free_conversion_context(&ctx);
39627     return STATUS_SUCCESS;
39628 }
39629 #endif /* _WIN64 */
39630
39631 static NTSTATUS thunk32_vkInvalidateMappedMemoryRanges(void *args)
39632 {
39633     struct
39634     {
39635         PTR32 device;
39636         uint32_t memoryRangeCount;
39637         PTR32 pMemoryRanges;
39638         VkResult result;
39639     } *params = args;
39640     const VkMappedMemoryRange *pMemoryRanges_host;
39641     struct conversion_context ctx;
39642
39643     TRACE("%#x, %u, %#x\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
39644
39645     init_conversion_context(&ctx);
39646     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win32_to_host(&ctx, (const VkMappedMemoryRange32 *)UlongToPtr(params->pMemoryRanges), params->memoryRangeCount);
39647     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkInvalidateMappedMemoryRanges(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->memoryRangeCount, pMemoryRanges_host);
39648     free_conversion_context(&ctx);
39649     return STATUS_SUCCESS;
39650 }
39651
39652 #ifdef _WIN64
39653 static NTSTATUS thunk64_vkMapMemory(void *args)
39654 {
39655     struct vkMapMemory_params *params = args;
39656
39657     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);
39658
39659     params->result = wine_vkMapMemory(params->device, params->memory, params->offset, params->size, params->flags, params->ppData);
39660     return STATUS_SUCCESS;
39661 }
39662 #endif /* _WIN64 */
39663
39664 static NTSTATUS thunk32_vkMapMemory(void *args)
39665 {
39666     struct
39667     {
39668         PTR32 device;
39669         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
39670         VkDeviceSize DECLSPEC_ALIGN(8) offset;
39671         VkDeviceSize DECLSPEC_ALIGN(8) size;
39672         VkMemoryMapFlags flags;
39673         PTR32 ppData;
39674         VkResult result;
39675     } *params = args;
39676
39677     TRACE("%#x, 0x%s, 0x%s, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->size), params->flags, params->ppData);
39678
39679     params->result = wine_vkMapMemory((VkDevice)UlongToPtr(params->device), params->memory, params->offset, params->size, params->flags, (void **)UlongToPtr(params->ppData));
39680     return STATUS_SUCCESS;
39681 }
39682
39683 #ifdef _WIN64
39684 static NTSTATUS thunk64_vkMapMemory2KHR(void *args)
39685 {
39686     struct vkMapMemory2KHR_params *params = args;
39687
39688     TRACE("%p, %p, %p\n", params->device, params->pMemoryMapInfo, params->ppData);
39689
39690     params->result = wine_vkMapMemory2KHR(params->device, params->pMemoryMapInfo, params->ppData);
39691     return STATUS_SUCCESS;
39692 }
39693 #endif /* _WIN64 */
39694
39695 static NTSTATUS thunk32_vkMapMemory2KHR(void *args)
39696 {
39697     struct
39698     {
39699         PTR32 device;
39700         PTR32 pMemoryMapInfo;
39701         PTR32 ppData;
39702         VkResult result;
39703     } *params = args;
39704     VkMemoryMapInfoKHR pMemoryMapInfo_host;
39705
39706     TRACE("%#x, %#x, %#x\n", params->device, params->pMemoryMapInfo, params->ppData);
39707
39708     convert_VkMemoryMapInfoKHR_win32_to_unwrapped_host((const VkMemoryMapInfoKHR32 *)UlongToPtr(params->pMemoryMapInfo), &pMemoryMapInfo_host);
39709     params->result = wine_vkMapMemory2KHR((VkDevice)UlongToPtr(params->device), &pMemoryMapInfo_host, (void **)UlongToPtr(params->ppData));
39710     return STATUS_SUCCESS;
39711 }
39712
39713 #ifdef _WIN64
39714 static NTSTATUS thunk64_vkMergePipelineCaches(void *args)
39715 {
39716     struct vkMergePipelineCaches_params *params = args;
39717
39718     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
39719
39720     params->result = wine_device_from_handle(params->device)->funcs.p_vkMergePipelineCaches(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
39721     return STATUS_SUCCESS;
39722 }
39723 #endif /* _WIN64 */
39724
39725 static NTSTATUS thunk32_vkMergePipelineCaches(void *args)
39726 {
39727     struct
39728     {
39729         PTR32 device;
39730         VkPipelineCache DECLSPEC_ALIGN(8) dstCache;
39731         uint32_t srcCacheCount;
39732         PTR32 pSrcCaches;
39733         VkResult result;
39734     } *params = args;
39735
39736     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
39737
39738     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkMergePipelineCaches(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->dstCache, params->srcCacheCount, (const VkPipelineCache *)UlongToPtr(params->pSrcCaches));
39739     return STATUS_SUCCESS;
39740 }
39741
39742 #ifdef _WIN64
39743 static NTSTATUS thunk64_vkMergeValidationCachesEXT(void *args)
39744 {
39745     struct vkMergeValidationCachesEXT_params *params = args;
39746
39747     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
39748
39749     params->result = wine_device_from_handle(params->device)->funcs.p_vkMergeValidationCachesEXT(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
39750     return STATUS_SUCCESS;
39751 }
39752 #endif /* _WIN64 */
39753
39754 static NTSTATUS thunk32_vkMergeValidationCachesEXT(void *args)
39755 {
39756     struct
39757     {
39758         PTR32 device;
39759         VkValidationCacheEXT DECLSPEC_ALIGN(8) dstCache;
39760         uint32_t srcCacheCount;
39761         PTR32 pSrcCaches;
39762         VkResult result;
39763     } *params = args;
39764
39765     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
39766
39767     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkMergeValidationCachesEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->dstCache, params->srcCacheCount, (const VkValidationCacheEXT *)UlongToPtr(params->pSrcCaches));
39768     return STATUS_SUCCESS;
39769 }
39770
39771 #ifdef _WIN64
39772 static NTSTATUS thunk64_vkQueueBeginDebugUtilsLabelEXT(void *args)
39773 {
39774     struct vkQueueBeginDebugUtilsLabelEXT_params *params = args;
39775
39776     TRACE("%p, %p\n", params->queue, params->pLabelInfo);
39777
39778     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueBeginDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue, params->pLabelInfo);
39779     return STATUS_SUCCESS;
39780 }
39781 #endif /* _WIN64 */
39782
39783 static NTSTATUS thunk32_vkQueueBeginDebugUtilsLabelEXT(void *args)
39784 {
39785     struct
39786     {
39787         PTR32 queue;
39788         PTR32 pLabelInfo;
39789     } *params = args;
39790     VkDebugUtilsLabelEXT pLabelInfo_host;
39791
39792     TRACE("%#x, %#x\n", params->queue, params->pLabelInfo);
39793
39794     convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
39795     wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueBeginDebugUtilsLabelEXT(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, &pLabelInfo_host);
39796     return STATUS_SUCCESS;
39797 }
39798
39799 #ifdef _WIN64
39800 static NTSTATUS thunk64_vkQueueBindSparse(void *args)
39801 {
39802     struct vkQueueBindSparse_params *params = args;
39803     const VkBindSparseInfo *pBindInfo_host;
39804     struct conversion_context ctx;
39805
39806     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->bindInfoCount, params->pBindInfo, wine_dbgstr_longlong(params->fence));
39807
39808     init_conversion_context(&ctx);
39809     pBindInfo_host = convert_VkBindSparseInfo_array_win64_to_host(&ctx, params->pBindInfo, params->bindInfoCount);
39810     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);
39811     free_conversion_context(&ctx);
39812     return STATUS_SUCCESS;
39813 }
39814 #endif /* _WIN64 */
39815
39816 static NTSTATUS thunk32_vkQueueBindSparse(void *args)
39817 {
39818     struct
39819     {
39820         PTR32 queue;
39821         uint32_t bindInfoCount;
39822         PTR32 pBindInfo;
39823         VkFence DECLSPEC_ALIGN(8) fence;
39824         VkResult result;
39825     } *params = args;
39826     const VkBindSparseInfo *pBindInfo_host;
39827     struct conversion_context ctx;
39828
39829     TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->bindInfoCount, params->pBindInfo, wine_dbgstr_longlong(params->fence));
39830
39831     init_conversion_context(&ctx);
39832     pBindInfo_host = convert_VkBindSparseInfo_array_win32_to_host(&ctx, (const VkBindSparseInfo32 *)UlongToPtr(params->pBindInfo), params->bindInfoCount);
39833     params->result = wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueBindSparse(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, params->bindInfoCount, pBindInfo_host, params->fence);
39834     free_conversion_context(&ctx);
39835     return STATUS_SUCCESS;
39836 }
39837
39838 #ifdef _WIN64
39839 static NTSTATUS thunk64_vkQueueEndDebugUtilsLabelEXT(void *args)
39840 {
39841     struct vkQueueEndDebugUtilsLabelEXT_params *params = args;
39842
39843     TRACE("%p\n", params->queue);
39844
39845     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueEndDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue);
39846     return STATUS_SUCCESS;
39847 }
39848 #endif /* _WIN64 */
39849
39850 static NTSTATUS thunk32_vkQueueEndDebugUtilsLabelEXT(void *args)
39851 {
39852     struct
39853     {
39854         PTR32 queue;
39855     } *params = args;
39856
39857     TRACE("%#x\n", params->queue);
39858
39859     wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueEndDebugUtilsLabelEXT(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue);
39860     return STATUS_SUCCESS;
39861 }
39862
39863 #ifdef _WIN64
39864 static NTSTATUS thunk64_vkQueueInsertDebugUtilsLabelEXT(void *args)
39865 {
39866     struct vkQueueInsertDebugUtilsLabelEXT_params *params = args;
39867
39868     TRACE("%p, %p\n", params->queue, params->pLabelInfo);
39869
39870     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueInsertDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue, params->pLabelInfo);
39871     return STATUS_SUCCESS;
39872 }
39873 #endif /* _WIN64 */
39874
39875 static NTSTATUS thunk32_vkQueueInsertDebugUtilsLabelEXT(void *args)
39876 {
39877     struct
39878     {
39879         PTR32 queue;
39880         PTR32 pLabelInfo;
39881     } *params = args;
39882     VkDebugUtilsLabelEXT pLabelInfo_host;
39883
39884     TRACE("%#x, %#x\n", params->queue, params->pLabelInfo);
39885
39886     convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
39887     wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueInsertDebugUtilsLabelEXT(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, &pLabelInfo_host);
39888     return STATUS_SUCCESS;
39889 }
39890
39891 #ifdef _WIN64
39892 static NTSTATUS thunk64_vkQueuePresentKHR(void *args)
39893 {
39894     struct vkQueuePresentKHR_params *params = args;
39895
39896     TRACE("%p, %p\n", params->queue, params->pPresentInfo);
39897
39898     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueuePresentKHR(wine_queue_from_handle(params->queue)->queue, params->pPresentInfo);
39899     return STATUS_SUCCESS;
39900 }
39901 #endif /* _WIN64 */
39902
39903 static NTSTATUS thunk32_vkQueuePresentKHR(void *args)
39904 {
39905     struct
39906     {
39907         PTR32 queue;
39908         PTR32 pPresentInfo;
39909         VkResult result;
39910     } *params = args;
39911     VkPresentInfoKHR pPresentInfo_host;
39912     struct conversion_context ctx;
39913
39914     TRACE("%#x, %#x\n", params->queue, params->pPresentInfo);
39915
39916     init_conversion_context(&ctx);
39917     convert_VkPresentInfoKHR_win32_to_host(&ctx, (const VkPresentInfoKHR32 *)UlongToPtr(params->pPresentInfo), &pPresentInfo_host);
39918     params->result = wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueuePresentKHR(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, &pPresentInfo_host);
39919     free_conversion_context(&ctx);
39920     return STATUS_SUCCESS;
39921 }
39922
39923 #ifdef _WIN64
39924 static NTSTATUS thunk64_vkQueueSetPerformanceConfigurationINTEL(void *args)
39925 {
39926     struct vkQueueSetPerformanceConfigurationINTEL_params *params = args;
39927
39928     TRACE("%p, 0x%s\n", params->queue, wine_dbgstr_longlong(params->configuration));
39929
39930     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSetPerformanceConfigurationINTEL(wine_queue_from_handle(params->queue)->queue, params->configuration);
39931     return STATUS_SUCCESS;
39932 }
39933 #endif /* _WIN64 */
39934
39935 static NTSTATUS thunk32_vkQueueSetPerformanceConfigurationINTEL(void *args)
39936 {
39937     struct
39938     {
39939         PTR32 queue;
39940         VkPerformanceConfigurationINTEL DECLSPEC_ALIGN(8) configuration;
39941         VkResult result;
39942     } *params = args;
39943
39944     TRACE("%#x, 0x%s\n", params->queue, wine_dbgstr_longlong(params->configuration));
39945
39946     params->result = wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueSetPerformanceConfigurationINTEL(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, params->configuration);
39947     return STATUS_SUCCESS;
39948 }
39949
39950 #ifdef _WIN64
39951 static NTSTATUS thunk64_vkQueueSubmit(void *args)
39952 {
39953     struct vkQueueSubmit_params *params = args;
39954     const VkSubmitInfo *pSubmits_host;
39955     struct conversion_context ctx;
39956
39957     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
39958
39959     init_conversion_context(&ctx);
39960     pSubmits_host = convert_VkSubmitInfo_array_win64_to_host(&ctx, params->pSubmits, params->submitCount);
39961     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);
39962     free_conversion_context(&ctx);
39963     return STATUS_SUCCESS;
39964 }
39965 #endif /* _WIN64 */
39966
39967 static NTSTATUS thunk32_vkQueueSubmit(void *args)
39968 {
39969     struct
39970     {
39971         PTR32 queue;
39972         uint32_t submitCount;
39973         PTR32 pSubmits;
39974         VkFence DECLSPEC_ALIGN(8) fence;
39975         VkResult result;
39976     } *params = args;
39977     const VkSubmitInfo *pSubmits_host;
39978     struct conversion_context ctx;
39979
39980     TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
39981
39982     init_conversion_context(&ctx);
39983     pSubmits_host = convert_VkSubmitInfo_array_win32_to_host(&ctx, (const VkSubmitInfo32 *)UlongToPtr(params->pSubmits), params->submitCount);
39984     params->result = wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueSubmit(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, params->submitCount, pSubmits_host, params->fence);
39985     free_conversion_context(&ctx);
39986     return STATUS_SUCCESS;
39987 }
39988
39989 #ifdef _WIN64
39990 static NTSTATUS thunk64_vkQueueSubmit2(void *args)
39991 {
39992     struct vkQueueSubmit2_params *params = args;
39993     const VkSubmitInfo2 *pSubmits_host;
39994     struct conversion_context ctx;
39995
39996     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
39997
39998     init_conversion_context(&ctx);
39999     pSubmits_host = convert_VkSubmitInfo2_array_win64_to_host(&ctx, params->pSubmits, params->submitCount);
40000     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);
40001     free_conversion_context(&ctx);
40002     return STATUS_SUCCESS;
40003 }
40004 #endif /* _WIN64 */
40005
40006 static NTSTATUS thunk32_vkQueueSubmit2(void *args)
40007 {
40008     struct
40009     {
40010         PTR32 queue;
40011         uint32_t submitCount;
40012         PTR32 pSubmits;
40013         VkFence DECLSPEC_ALIGN(8) fence;
40014         VkResult result;
40015     } *params = args;
40016     const VkSubmitInfo2 *pSubmits_host;
40017     struct conversion_context ctx;
40018
40019     TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
40020
40021     init_conversion_context(&ctx);
40022     pSubmits_host = convert_VkSubmitInfo2_array_win32_to_host(&ctx, (const VkSubmitInfo232 *)UlongToPtr(params->pSubmits), params->submitCount);
40023     params->result = wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueSubmit2(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, params->submitCount, pSubmits_host, params->fence);
40024     free_conversion_context(&ctx);
40025     return STATUS_SUCCESS;
40026 }
40027
40028 #ifdef _WIN64
40029 static NTSTATUS thunk64_vkQueueSubmit2KHR(void *args)
40030 {
40031     struct vkQueueSubmit2KHR_params *params = args;
40032     const VkSubmitInfo2 *pSubmits_host;
40033     struct conversion_context ctx;
40034
40035     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
40036
40037     init_conversion_context(&ctx);
40038     pSubmits_host = convert_VkSubmitInfo2_array_win64_to_host(&ctx, params->pSubmits, params->submitCount);
40039     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);
40040     free_conversion_context(&ctx);
40041     return STATUS_SUCCESS;
40042 }
40043 #endif /* _WIN64 */
40044
40045 static NTSTATUS thunk32_vkQueueSubmit2KHR(void *args)
40046 {
40047     struct
40048     {
40049         PTR32 queue;
40050         uint32_t submitCount;
40051         PTR32 pSubmits;
40052         VkFence DECLSPEC_ALIGN(8) fence;
40053         VkResult result;
40054     } *params = args;
40055     const VkSubmitInfo2 *pSubmits_host;
40056     struct conversion_context ctx;
40057
40058     TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
40059
40060     init_conversion_context(&ctx);
40061     pSubmits_host = convert_VkSubmitInfo2_array_win32_to_host(&ctx, (const VkSubmitInfo232 *)UlongToPtr(params->pSubmits), params->submitCount);
40062     params->result = wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueSubmit2KHR(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, params->submitCount, pSubmits_host, params->fence);
40063     free_conversion_context(&ctx);
40064     return STATUS_SUCCESS;
40065 }
40066
40067 #ifdef _WIN64
40068 static NTSTATUS thunk64_vkQueueWaitIdle(void *args)
40069 {
40070     struct vkQueueWaitIdle_params *params = args;
40071
40072     TRACE("%p\n", params->queue);
40073
40074     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueWaitIdle(wine_queue_from_handle(params->queue)->queue);
40075     return STATUS_SUCCESS;
40076 }
40077 #endif /* _WIN64 */
40078
40079 static NTSTATUS thunk32_vkQueueWaitIdle(void *args)
40080 {
40081     struct
40082     {
40083         PTR32 queue;
40084         VkResult result;
40085     } *params = args;
40086
40087     TRACE("%#x\n", params->queue);
40088
40089     params->result = wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueWaitIdle(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue);
40090     return STATUS_SUCCESS;
40091 }
40092
40093 #ifdef _WIN64
40094 static NTSTATUS thunk64_vkReleasePerformanceConfigurationINTEL(void *args)
40095 {
40096     struct vkReleasePerformanceConfigurationINTEL_params *params = args;
40097
40098     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->configuration));
40099
40100     params->result = wine_device_from_handle(params->device)->funcs.p_vkReleasePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->configuration);
40101     return STATUS_SUCCESS;
40102 }
40103 #endif /* _WIN64 */
40104
40105 static NTSTATUS thunk32_vkReleasePerformanceConfigurationINTEL(void *args)
40106 {
40107     struct
40108     {
40109         PTR32 device;
40110         VkPerformanceConfigurationINTEL DECLSPEC_ALIGN(8) configuration;
40111         VkResult result;
40112     } *params = args;
40113
40114     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->configuration));
40115
40116     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkReleasePerformanceConfigurationINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->configuration);
40117     return STATUS_SUCCESS;
40118 }
40119
40120 #ifdef _WIN64
40121 static NTSTATUS thunk64_vkReleaseProfilingLockKHR(void *args)
40122 {
40123     struct vkReleaseProfilingLockKHR_params *params = args;
40124
40125     TRACE("%p\n", params->device);
40126
40127     wine_device_from_handle(params->device)->funcs.p_vkReleaseProfilingLockKHR(wine_device_from_handle(params->device)->device);
40128     return STATUS_SUCCESS;
40129 }
40130 #endif /* _WIN64 */
40131
40132 static NTSTATUS thunk32_vkReleaseProfilingLockKHR(void *args)
40133 {
40134     struct
40135     {
40136         PTR32 device;
40137     } *params = args;
40138
40139     TRACE("%#x\n", params->device);
40140
40141     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkReleaseProfilingLockKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device);
40142     return STATUS_SUCCESS;
40143 }
40144
40145 #ifdef _WIN64
40146 static NTSTATUS thunk64_vkReleaseSwapchainImagesEXT(void *args)
40147 {
40148     struct vkReleaseSwapchainImagesEXT_params *params = args;
40149
40150     TRACE("%p, %p\n", params->device, params->pReleaseInfo);
40151
40152     params->result = wine_device_from_handle(params->device)->funcs.p_vkReleaseSwapchainImagesEXT(wine_device_from_handle(params->device)->device, params->pReleaseInfo);
40153     return STATUS_SUCCESS;
40154 }
40155 #endif /* _WIN64 */
40156
40157 static NTSTATUS thunk32_vkReleaseSwapchainImagesEXT(void *args)
40158 {
40159     struct
40160     {
40161         PTR32 device;
40162         PTR32 pReleaseInfo;
40163         VkResult result;
40164     } *params = args;
40165     VkReleaseSwapchainImagesInfoEXT pReleaseInfo_host;
40166
40167     TRACE("%#x, %#x\n", params->device, params->pReleaseInfo);
40168
40169     convert_VkReleaseSwapchainImagesInfoEXT_win32_to_host((const VkReleaseSwapchainImagesInfoEXT32 *)UlongToPtr(params->pReleaseInfo), &pReleaseInfo_host);
40170     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkReleaseSwapchainImagesEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pReleaseInfo_host);
40171     return STATUS_SUCCESS;
40172 }
40173
40174 #ifdef _WIN64
40175 static NTSTATUS thunk64_vkResetCommandBuffer(void *args)
40176 {
40177     struct vkResetCommandBuffer_params *params = args;
40178
40179     TRACE("%p, %#x\n", params->commandBuffer, params->flags);
40180
40181     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkResetCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->flags);
40182     return STATUS_SUCCESS;
40183 }
40184 #endif /* _WIN64 */
40185
40186 static NTSTATUS thunk32_vkResetCommandBuffer(void *args)
40187 {
40188     struct
40189     {
40190         PTR32 commandBuffer;
40191         VkCommandBufferResetFlags flags;
40192         VkResult result;
40193     } *params = args;
40194
40195     TRACE("%#x, %#x\n", params->commandBuffer, params->flags);
40196
40197     params->result = wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkResetCommandBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->flags);
40198     return STATUS_SUCCESS;
40199 }
40200
40201 #ifdef _WIN64
40202 static NTSTATUS thunk64_vkResetCommandPool(void *args)
40203 {
40204     struct vkResetCommandPool_params *params = args;
40205
40206     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
40207
40208     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);
40209     return STATUS_SUCCESS;
40210 }
40211 #endif /* _WIN64 */
40212
40213 static NTSTATUS thunk32_vkResetCommandPool(void *args)
40214 {
40215     struct
40216     {
40217         PTR32 device;
40218         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
40219         VkCommandPoolResetFlags flags;
40220         VkResult result;
40221     } *params = args;
40222
40223     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
40224
40225     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkResetCommandPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, wine_cmd_pool_from_handle(params->commandPool)->command_pool, params->flags);
40226     return STATUS_SUCCESS;
40227 }
40228
40229 #ifdef _WIN64
40230 static NTSTATUS thunk64_vkResetDescriptorPool(void *args)
40231 {
40232     struct vkResetDescriptorPool_params *params = args;
40233
40234     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->flags);
40235
40236     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, params->flags);
40237     return STATUS_SUCCESS;
40238 }
40239 #endif /* _WIN64 */
40240
40241 static NTSTATUS thunk32_vkResetDescriptorPool(void *args)
40242 {
40243     struct
40244     {
40245         PTR32 device;
40246         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
40247         VkDescriptorPoolResetFlags flags;
40248         VkResult result;
40249     } *params = args;
40250
40251     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->flags);
40252
40253     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkResetDescriptorPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorPool, params->flags);
40254     return STATUS_SUCCESS;
40255 }
40256
40257 #ifdef _WIN64
40258 static NTSTATUS thunk64_vkResetEvent(void *args)
40259 {
40260     struct vkResetEvent_params *params = args;
40261
40262     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
40263
40264     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetEvent(wine_device_from_handle(params->device)->device, params->event);
40265     return STATUS_SUCCESS;
40266 }
40267 #endif /* _WIN64 */
40268
40269 static NTSTATUS thunk32_vkResetEvent(void *args)
40270 {
40271     struct
40272     {
40273         PTR32 device;
40274         VkEvent DECLSPEC_ALIGN(8) event;
40275         VkResult result;
40276     } *params = args;
40277
40278     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
40279
40280     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkResetEvent(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event);
40281     return STATUS_SUCCESS;
40282 }
40283
40284 #ifdef _WIN64
40285 static NTSTATUS thunk64_vkResetFences(void *args)
40286 {
40287     struct vkResetFences_params *params = args;
40288
40289     TRACE("%p, %u, %p\n", params->device, params->fenceCount, params->pFences);
40290
40291     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences);
40292     return STATUS_SUCCESS;
40293 }
40294 #endif /* _WIN64 */
40295
40296 static NTSTATUS thunk32_vkResetFences(void *args)
40297 {
40298     struct
40299     {
40300         PTR32 device;
40301         uint32_t fenceCount;
40302         PTR32 pFences;
40303         VkResult result;
40304     } *params = args;
40305
40306     TRACE("%#x, %u, %#x\n", params->device, params->fenceCount, params->pFences);
40307
40308     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkResetFences(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->fenceCount, (const VkFence *)UlongToPtr(params->pFences));
40309     return STATUS_SUCCESS;
40310 }
40311
40312 #ifdef _WIN64
40313 static NTSTATUS thunk64_vkResetQueryPool(void *args)
40314 {
40315     struct vkResetQueryPool_params *params = args;
40316
40317     TRACE("%p, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
40318
40319     wine_device_from_handle(params->device)->funcs.p_vkResetQueryPool(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount);
40320     return STATUS_SUCCESS;
40321 }
40322 #endif /* _WIN64 */
40323
40324 static NTSTATUS thunk32_vkResetQueryPool(void *args)
40325 {
40326     struct
40327     {
40328         PTR32 device;
40329         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
40330         uint32_t firstQuery;
40331         uint32_t queryCount;
40332     } *params = args;
40333
40334     TRACE("%#x, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
40335
40336     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkResetQueryPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->queryPool, params->firstQuery, params->queryCount);
40337     return STATUS_SUCCESS;
40338 }
40339
40340 #ifdef _WIN64
40341 static NTSTATUS thunk64_vkResetQueryPoolEXT(void *args)
40342 {
40343     struct vkResetQueryPoolEXT_params *params = args;
40344
40345     TRACE("%p, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
40346
40347     wine_device_from_handle(params->device)->funcs.p_vkResetQueryPoolEXT(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount);
40348     return STATUS_SUCCESS;
40349 }
40350 #endif /* _WIN64 */
40351
40352 static NTSTATUS thunk32_vkResetQueryPoolEXT(void *args)
40353 {
40354     struct
40355     {
40356         PTR32 device;
40357         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
40358         uint32_t firstQuery;
40359         uint32_t queryCount;
40360     } *params = args;
40361
40362     TRACE("%#x, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
40363
40364     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkResetQueryPoolEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->queryPool, params->firstQuery, params->queryCount);
40365     return STATUS_SUCCESS;
40366 }
40367
40368 #ifdef _WIN64
40369 static NTSTATUS thunk64_vkSetDebugUtilsObjectNameEXT(void *args)
40370 {
40371     struct vkSetDebugUtilsObjectNameEXT_params *params = args;
40372     VkDebugUtilsObjectNameInfoEXT pNameInfo_host;
40373
40374     TRACE("%p, %p\n", params->device, params->pNameInfo);
40375
40376     convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(params->pNameInfo, &pNameInfo_host);
40377     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
40378     return STATUS_SUCCESS;
40379 }
40380 #endif /* _WIN64 */
40381
40382 static NTSTATUS thunk32_vkSetDebugUtilsObjectNameEXT(void *args)
40383 {
40384     struct
40385     {
40386         PTR32 device;
40387         PTR32 pNameInfo;
40388         VkResult result;
40389     } *params = args;
40390     VkDebugUtilsObjectNameInfoEXT pNameInfo_host;
40391
40392     TRACE("%#x, %#x\n", params->device, params->pNameInfo);
40393
40394     convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host((const VkDebugUtilsObjectNameInfoEXT32 *)UlongToPtr(params->pNameInfo), &pNameInfo_host);
40395     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetDebugUtilsObjectNameEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pNameInfo_host);
40396     return STATUS_SUCCESS;
40397 }
40398
40399 #ifdef _WIN64
40400 static NTSTATUS thunk64_vkSetDebugUtilsObjectTagEXT(void *args)
40401 {
40402     struct vkSetDebugUtilsObjectTagEXT_params *params = args;
40403     VkDebugUtilsObjectTagInfoEXT pTagInfo_host;
40404
40405     TRACE("%p, %p\n", params->device, params->pTagInfo);
40406
40407     convert_VkDebugUtilsObjectTagInfoEXT_win64_to_host(params->pTagInfo, &pTagInfo_host);
40408     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
40409     return STATUS_SUCCESS;
40410 }
40411 #endif /* _WIN64 */
40412
40413 static NTSTATUS thunk32_vkSetDebugUtilsObjectTagEXT(void *args)
40414 {
40415     struct
40416     {
40417         PTR32 device;
40418         PTR32 pTagInfo;
40419         VkResult result;
40420     } *params = args;
40421     VkDebugUtilsObjectTagInfoEXT pTagInfo_host;
40422
40423     TRACE("%#x, %#x\n", params->device, params->pTagInfo);
40424
40425     convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host((const VkDebugUtilsObjectTagInfoEXT32 *)UlongToPtr(params->pTagInfo), &pTagInfo_host);
40426     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetDebugUtilsObjectTagEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pTagInfo_host);
40427     return STATUS_SUCCESS;
40428 }
40429
40430 #ifdef _WIN64
40431 static NTSTATUS thunk64_vkSetDeviceMemoryPriorityEXT(void *args)
40432 {
40433     struct vkSetDeviceMemoryPriorityEXT_params *params = args;
40434
40435     TRACE("%p, 0x%s, %f\n", params->device, wine_dbgstr_longlong(params->memory), params->priority);
40436
40437     wine_device_from_handle(params->device)->funcs.p_vkSetDeviceMemoryPriorityEXT(wine_device_from_handle(params->device)->device, wine_device_memory_from_handle(params->memory)->memory, params->priority);
40438     return STATUS_SUCCESS;
40439 }
40440 #endif /* _WIN64 */
40441
40442 static NTSTATUS thunk32_vkSetDeviceMemoryPriorityEXT(void *args)
40443 {
40444     struct
40445     {
40446         PTR32 device;
40447         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
40448         float priority;
40449     } *params = args;
40450
40451     TRACE("%#x, 0x%s, %f\n", params->device, wine_dbgstr_longlong(params->memory), params->priority);
40452
40453     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetDeviceMemoryPriorityEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, wine_device_memory_from_handle(params->memory)->memory, params->priority);
40454     return STATUS_SUCCESS;
40455 }
40456
40457 #ifdef _WIN64
40458 static NTSTATUS thunk64_vkSetEvent(void *args)
40459 {
40460     struct vkSetEvent_params *params = args;
40461
40462     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
40463
40464     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetEvent(wine_device_from_handle(params->device)->device, params->event);
40465     return STATUS_SUCCESS;
40466 }
40467 #endif /* _WIN64 */
40468
40469 static NTSTATUS thunk32_vkSetEvent(void *args)
40470 {
40471     struct
40472     {
40473         PTR32 device;
40474         VkEvent DECLSPEC_ALIGN(8) event;
40475         VkResult result;
40476     } *params = args;
40477
40478     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
40479
40480     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetEvent(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event);
40481     return STATUS_SUCCESS;
40482 }
40483
40484 #ifdef _WIN64
40485 static NTSTATUS thunk64_vkSetHdrMetadataEXT(void *args)
40486 {
40487     struct vkSetHdrMetadataEXT_params *params = args;
40488
40489     TRACE("%p, %u, %p, %p\n", params->device, params->swapchainCount, params->pSwapchains, params->pMetadata);
40490
40491     wine_device_from_handle(params->device)->funcs.p_vkSetHdrMetadataEXT(wine_device_from_handle(params->device)->device, params->swapchainCount, params->pSwapchains, params->pMetadata);
40492     return STATUS_SUCCESS;
40493 }
40494 #endif /* _WIN64 */
40495
40496 static NTSTATUS thunk32_vkSetHdrMetadataEXT(void *args)
40497 {
40498     struct
40499     {
40500         PTR32 device;
40501         uint32_t swapchainCount;
40502         PTR32 pSwapchains;
40503         PTR32 pMetadata;
40504     } *params = args;
40505     const VkHdrMetadataEXT *pMetadata_host;
40506     struct conversion_context ctx;
40507
40508     TRACE("%#x, %u, %#x, %#x\n", params->device, params->swapchainCount, params->pSwapchains, params->pMetadata);
40509
40510     init_conversion_context(&ctx);
40511     pMetadata_host = convert_VkHdrMetadataEXT_array_win32_to_host(&ctx, (const VkHdrMetadataEXT32 *)UlongToPtr(params->pMetadata), params->swapchainCount);
40512     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetHdrMetadataEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->swapchainCount, (const VkSwapchainKHR *)UlongToPtr(params->pSwapchains), pMetadata_host);
40513     free_conversion_context(&ctx);
40514     return STATUS_SUCCESS;
40515 }
40516
40517 #ifdef _WIN64
40518 static NTSTATUS thunk64_vkSetPrivateData(void *args)
40519 {
40520     struct vkSetPrivateData_params *params = args;
40521
40522     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));
40523
40524     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);
40525     return STATUS_SUCCESS;
40526 }
40527 #endif /* _WIN64 */
40528
40529 static NTSTATUS thunk32_vkSetPrivateData(void *args)
40530 {
40531     struct
40532     {
40533         PTR32 device;
40534         VkObjectType objectType;
40535         uint64_t DECLSPEC_ALIGN(8) objectHandle;
40536         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
40537         uint64_t DECLSPEC_ALIGN(8) data;
40538         VkResult result;
40539     } *params = args;
40540
40541     TRACE("%#x, %#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));
40542
40543     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetPrivateData(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->data);
40544     return STATUS_SUCCESS;
40545 }
40546
40547 #ifdef _WIN64
40548 static NTSTATUS thunk64_vkSetPrivateDataEXT(void *args)
40549 {
40550     struct vkSetPrivateDataEXT_params *params = args;
40551
40552     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));
40553
40554     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);
40555     return STATUS_SUCCESS;
40556 }
40557 #endif /* _WIN64 */
40558
40559 static NTSTATUS thunk32_vkSetPrivateDataEXT(void *args)
40560 {
40561     struct
40562     {
40563         PTR32 device;
40564         VkObjectType objectType;
40565         uint64_t DECLSPEC_ALIGN(8) objectHandle;
40566         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
40567         uint64_t DECLSPEC_ALIGN(8) data;
40568         VkResult result;
40569     } *params = args;
40570
40571     TRACE("%#x, %#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));
40572
40573     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetPrivateDataEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->data);
40574     return STATUS_SUCCESS;
40575 }
40576
40577 #ifdef _WIN64
40578 static NTSTATUS thunk64_vkSignalSemaphore(void *args)
40579 {
40580     struct vkSignalSemaphore_params *params = args;
40581
40582     TRACE("%p, %p\n", params->device, params->pSignalInfo);
40583
40584     params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphore(wine_device_from_handle(params->device)->device, params->pSignalInfo);
40585     return STATUS_SUCCESS;
40586 }
40587 #endif /* _WIN64 */
40588
40589 static NTSTATUS thunk32_vkSignalSemaphore(void *args)
40590 {
40591     struct
40592     {
40593         PTR32 device;
40594         PTR32 pSignalInfo;
40595         VkResult result;
40596     } *params = args;
40597     VkSemaphoreSignalInfo pSignalInfo_host;
40598
40599     TRACE("%#x, %#x\n", params->device, params->pSignalInfo);
40600
40601     convert_VkSemaphoreSignalInfo_win32_to_host((const VkSemaphoreSignalInfo32 *)UlongToPtr(params->pSignalInfo), &pSignalInfo_host);
40602     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSignalSemaphore(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pSignalInfo_host);
40603     return STATUS_SUCCESS;
40604 }
40605
40606 #ifdef _WIN64
40607 static NTSTATUS thunk64_vkSignalSemaphoreKHR(void *args)
40608 {
40609     struct vkSignalSemaphoreKHR_params *params = args;
40610
40611     TRACE("%p, %p\n", params->device, params->pSignalInfo);
40612
40613     params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphoreKHR(wine_device_from_handle(params->device)->device, params->pSignalInfo);
40614     return STATUS_SUCCESS;
40615 }
40616 #endif /* _WIN64 */
40617
40618 static NTSTATUS thunk32_vkSignalSemaphoreKHR(void *args)
40619 {
40620     struct
40621     {
40622         PTR32 device;
40623         PTR32 pSignalInfo;
40624         VkResult result;
40625     } *params = args;
40626     VkSemaphoreSignalInfo pSignalInfo_host;
40627
40628     TRACE("%#x, %#x\n", params->device, params->pSignalInfo);
40629
40630     convert_VkSemaphoreSignalInfo_win32_to_host((const VkSemaphoreSignalInfo32 *)UlongToPtr(params->pSignalInfo), &pSignalInfo_host);
40631     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSignalSemaphoreKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pSignalInfo_host);
40632     return STATUS_SUCCESS;
40633 }
40634
40635 #ifdef _WIN64
40636 static NTSTATUS thunk64_vkSubmitDebugUtilsMessageEXT(void *args)
40637 {
40638     struct vkSubmitDebugUtilsMessageEXT_params *params = args;
40639     VkDebugUtilsMessengerCallbackDataEXT pCallbackData_host;
40640     struct conversion_context ctx;
40641
40642     TRACE("%p, %#x, %#x, %p\n", params->instance, params->messageSeverity, params->messageTypes, params->pCallbackData);
40643
40644     init_conversion_context(&ctx);
40645     convert_VkDebugUtilsMessengerCallbackDataEXT_win64_to_host(&ctx, params->pCallbackData, &pCallbackData_host);
40646     wine_instance_from_handle(params->instance)->funcs.p_vkSubmitDebugUtilsMessageEXT(wine_instance_from_handle(params->instance)->instance, params->messageSeverity, params->messageTypes, &pCallbackData_host);
40647     free_conversion_context(&ctx);
40648     return STATUS_SUCCESS;
40649 }
40650 #endif /* _WIN64 */
40651
40652 static NTSTATUS thunk32_vkSubmitDebugUtilsMessageEXT(void *args)
40653 {
40654     struct
40655     {
40656         PTR32 instance;
40657         VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity;
40658         VkDebugUtilsMessageTypeFlagsEXT messageTypes;
40659         PTR32 pCallbackData;
40660     } *params = args;
40661     VkDebugUtilsMessengerCallbackDataEXT pCallbackData_host;
40662     struct conversion_context ctx;
40663
40664     TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->messageSeverity, params->messageTypes, params->pCallbackData);
40665
40666     init_conversion_context(&ctx);
40667     convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(&ctx, (const VkDebugUtilsMessengerCallbackDataEXT32 *)UlongToPtr(params->pCallbackData), &pCallbackData_host);
40668     wine_instance_from_handle((VkInstance)UlongToPtr(params->instance))->funcs.p_vkSubmitDebugUtilsMessageEXT(wine_instance_from_handle((VkInstance)UlongToPtr(params->instance))->instance, params->messageSeverity, params->messageTypes, &pCallbackData_host);
40669     free_conversion_context(&ctx);
40670     return STATUS_SUCCESS;
40671 }
40672
40673 #ifdef _WIN64
40674 static NTSTATUS thunk64_vkTrimCommandPool(void *args)
40675 {
40676     struct vkTrimCommandPool_params *params = args;
40677
40678     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
40679
40680     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);
40681     return STATUS_SUCCESS;
40682 }
40683 #endif /* _WIN64 */
40684
40685 static NTSTATUS thunk32_vkTrimCommandPool(void *args)
40686 {
40687     struct
40688     {
40689         PTR32 device;
40690         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
40691         VkCommandPoolTrimFlags flags;
40692     } *params = args;
40693
40694     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
40695
40696     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkTrimCommandPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, wine_cmd_pool_from_handle(params->commandPool)->command_pool, params->flags);
40697     return STATUS_SUCCESS;
40698 }
40699
40700 #ifdef _WIN64
40701 static NTSTATUS thunk64_vkTrimCommandPoolKHR(void *args)
40702 {
40703     struct vkTrimCommandPoolKHR_params *params = args;
40704
40705     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
40706
40707     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);
40708     return STATUS_SUCCESS;
40709 }
40710 #endif /* _WIN64 */
40711
40712 static NTSTATUS thunk32_vkTrimCommandPoolKHR(void *args)
40713 {
40714     struct
40715     {
40716         PTR32 device;
40717         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
40718         VkCommandPoolTrimFlags flags;
40719     } *params = args;
40720
40721     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
40722
40723     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkTrimCommandPoolKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, wine_cmd_pool_from_handle(params->commandPool)->command_pool, params->flags);
40724     return STATUS_SUCCESS;
40725 }
40726
40727 #ifdef _WIN64
40728 static NTSTATUS thunk64_vkUninitializePerformanceApiINTEL(void *args)
40729 {
40730     struct vkUninitializePerformanceApiINTEL_params *params = args;
40731
40732     TRACE("%p\n", params->device);
40733
40734     wine_device_from_handle(params->device)->funcs.p_vkUninitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device);
40735     return STATUS_SUCCESS;
40736 }
40737 #endif /* _WIN64 */
40738
40739 static NTSTATUS thunk32_vkUninitializePerformanceApiINTEL(void *args)
40740 {
40741     struct
40742     {
40743         PTR32 device;
40744     } *params = args;
40745
40746     TRACE("%#x\n", params->device);
40747
40748     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUninitializePerformanceApiINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device);
40749     return STATUS_SUCCESS;
40750 }
40751
40752 #ifdef _WIN64
40753 static NTSTATUS thunk64_vkUnmapMemory(void *args)
40754 {
40755     struct vkUnmapMemory_params *params = args;
40756
40757     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->memory));
40758
40759     wine_vkUnmapMemory(params->device, params->memory);
40760     return STATUS_SUCCESS;
40761 }
40762 #endif /* _WIN64 */
40763
40764 static NTSTATUS thunk32_vkUnmapMemory(void *args)
40765 {
40766     struct
40767     {
40768         PTR32 device;
40769         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
40770     } *params = args;
40771
40772     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->memory));
40773
40774     wine_vkUnmapMemory((VkDevice)UlongToPtr(params->device), params->memory);
40775     return STATUS_SUCCESS;
40776 }
40777
40778 #ifdef _WIN64
40779 static NTSTATUS thunk64_vkUnmapMemory2KHR(void *args)
40780 {
40781     struct vkUnmapMemory2KHR_params *params = args;
40782
40783     TRACE("%p, %p\n", params->device, params->pMemoryUnmapInfo);
40784
40785     params->result = wine_vkUnmapMemory2KHR(params->device, params->pMemoryUnmapInfo);
40786     return STATUS_SUCCESS;
40787 }
40788 #endif /* _WIN64 */
40789
40790 static NTSTATUS thunk32_vkUnmapMemory2KHR(void *args)
40791 {
40792     struct
40793     {
40794         PTR32 device;
40795         PTR32 pMemoryUnmapInfo;
40796         VkResult result;
40797     } *params = args;
40798     VkMemoryUnmapInfoKHR pMemoryUnmapInfo_host;
40799
40800     TRACE("%#x, %#x\n", params->device, params->pMemoryUnmapInfo);
40801
40802     convert_VkMemoryUnmapInfoKHR_win32_to_unwrapped_host((const VkMemoryUnmapInfoKHR32 *)UlongToPtr(params->pMemoryUnmapInfo), &pMemoryUnmapInfo_host);
40803     params->result = wine_vkUnmapMemory2KHR((VkDevice)UlongToPtr(params->device), &pMemoryUnmapInfo_host);
40804     return STATUS_SUCCESS;
40805 }
40806
40807 #ifdef _WIN64
40808 static void thunk64_vkUpdateDescriptorSetWithTemplate(void *args)
40809 {
40810     struct vkUpdateDescriptorSetWithTemplate_params *params = args;
40811
40812     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplate(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
40813 }
40814 #endif /* _WIN64 */
40815
40816 static void thunk32_vkUpdateDescriptorSetWithTemplate(void *args)
40817 {
40818     struct
40819     {
40820         PTR32 device;
40821         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
40822         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
40823         PTR32 pData;
40824     } *params = args;
40825
40826     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUpdateDescriptorSetWithTemplate(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorSet, params->descriptorUpdateTemplate, (const void *)UlongToPtr(params->pData));
40827 }
40828
40829 #ifdef _WIN64
40830 static NTSTATUS thunk64_vkUpdateDescriptorSetWithTemplateKHR(void *args)
40831 {
40832     struct vkUpdateDescriptorSetWithTemplateKHR_params *params = args;
40833
40834     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
40835
40836     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplateKHR(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
40837     return STATUS_SUCCESS;
40838 }
40839 #endif /* _WIN64 */
40840
40841 static NTSTATUS thunk32_vkUpdateDescriptorSetWithTemplateKHR(void *args)
40842 {
40843     struct
40844     {
40845         PTR32 device;
40846         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
40847         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
40848         PTR32 pData;
40849     } *params = args;
40850
40851     TRACE("%#x, 0x%s, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
40852
40853     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUpdateDescriptorSetWithTemplateKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorSet, params->descriptorUpdateTemplate, (const void *)UlongToPtr(params->pData));
40854     return STATUS_SUCCESS;
40855 }
40856
40857 #ifdef _WIN64
40858 static void thunk64_vkUpdateDescriptorSets(void *args)
40859 {
40860     struct vkUpdateDescriptorSets_params *params = args;
40861
40862     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorWriteCount, params->pDescriptorWrites, params->descriptorCopyCount, params->pDescriptorCopies);
40863 }
40864 #endif /* _WIN64 */
40865
40866 static void thunk32_vkUpdateDescriptorSets(void *args)
40867 {
40868     struct
40869     {
40870         PTR32 device;
40871         uint32_t descriptorWriteCount;
40872         PTR32 pDescriptorWrites;
40873         uint32_t descriptorCopyCount;
40874         PTR32 pDescriptorCopies;
40875     } *params = args;
40876     const VkWriteDescriptorSet *pDescriptorWrites_host;
40877     const VkCopyDescriptorSet *pDescriptorCopies_host;
40878     struct conversion_context ctx;
40879
40880     init_conversion_context(&ctx);
40881     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win32_to_host(&ctx, (const VkWriteDescriptorSet32 *)UlongToPtr(params->pDescriptorWrites), params->descriptorWriteCount);
40882     pDescriptorCopies_host = convert_VkCopyDescriptorSet_array_win32_to_host(&ctx, (const VkCopyDescriptorSet32 *)UlongToPtr(params->pDescriptorCopies), params->descriptorCopyCount);
40883     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUpdateDescriptorSets(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorWriteCount, pDescriptorWrites_host, params->descriptorCopyCount, pDescriptorCopies_host);
40884     free_conversion_context(&ctx);
40885 }
40886
40887 #ifdef _WIN64
40888 static NTSTATUS thunk64_vkWaitForFences(void *args)
40889 {
40890     struct vkWaitForFences_params *params = args;
40891
40892     TRACE("%p, %u, %p, %u, 0x%s\n", params->device, params->fenceCount, params->pFences, params->waitAll, wine_dbgstr_longlong(params->timeout));
40893
40894     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);
40895     return STATUS_SUCCESS;
40896 }
40897 #endif /* _WIN64 */
40898
40899 static NTSTATUS thunk32_vkWaitForFences(void *args)
40900 {
40901     struct
40902     {
40903         PTR32 device;
40904         uint32_t fenceCount;
40905         PTR32 pFences;
40906         VkBool32 waitAll;
40907         uint64_t DECLSPEC_ALIGN(8) timeout;
40908         VkResult result;
40909     } *params = args;
40910
40911     TRACE("%#x, %u, %#x, %u, 0x%s\n", params->device, params->fenceCount, params->pFences, params->waitAll, wine_dbgstr_longlong(params->timeout));
40912
40913     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkWaitForFences(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->fenceCount, (const VkFence *)UlongToPtr(params->pFences), params->waitAll, params->timeout);
40914     return STATUS_SUCCESS;
40915 }
40916
40917 #ifdef _WIN64
40918 static NTSTATUS thunk64_vkWaitForPresentKHR(void *args)
40919 {
40920     struct vkWaitForPresentKHR_params *params = args;
40921
40922     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));
40923
40924     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitForPresentKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->presentId, params->timeout);
40925     return STATUS_SUCCESS;
40926 }
40927 #endif /* _WIN64 */
40928
40929 static NTSTATUS thunk32_vkWaitForPresentKHR(void *args)
40930 {
40931     struct
40932     {
40933         PTR32 device;
40934         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
40935         uint64_t DECLSPEC_ALIGN(8) presentId;
40936         uint64_t DECLSPEC_ALIGN(8) timeout;
40937         VkResult result;
40938     } *params = args;
40939
40940     TRACE("%#x, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->swapchain), wine_dbgstr_longlong(params->presentId), wine_dbgstr_longlong(params->timeout));
40941
40942     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkWaitForPresentKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->swapchain, params->presentId, params->timeout);
40943     return STATUS_SUCCESS;
40944 }
40945
40946 #ifdef _WIN64
40947 static NTSTATUS thunk64_vkWaitSemaphores(void *args)
40948 {
40949     struct vkWaitSemaphores_params *params = args;
40950
40951     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
40952
40953     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphores(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
40954     return STATUS_SUCCESS;
40955 }
40956 #endif /* _WIN64 */
40957
40958 static NTSTATUS thunk32_vkWaitSemaphores(void *args)
40959 {
40960     struct
40961     {
40962         PTR32 device;
40963         PTR32 pWaitInfo;
40964         uint64_t DECLSPEC_ALIGN(8) timeout;
40965         VkResult result;
40966     } *params = args;
40967     VkSemaphoreWaitInfo pWaitInfo_host;
40968
40969     TRACE("%#x, %#x, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
40970
40971     convert_VkSemaphoreWaitInfo_win32_to_host((const VkSemaphoreWaitInfo32 *)UlongToPtr(params->pWaitInfo), &pWaitInfo_host);
40972     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkWaitSemaphores(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pWaitInfo_host, params->timeout);
40973     return STATUS_SUCCESS;
40974 }
40975
40976 #ifdef _WIN64
40977 static NTSTATUS thunk64_vkWaitSemaphoresKHR(void *args)
40978 {
40979     struct vkWaitSemaphoresKHR_params *params = args;
40980
40981     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
40982
40983     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphoresKHR(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
40984     return STATUS_SUCCESS;
40985 }
40986 #endif /* _WIN64 */
40987
40988 static NTSTATUS thunk32_vkWaitSemaphoresKHR(void *args)
40989 {
40990     struct
40991     {
40992         PTR32 device;
40993         PTR32 pWaitInfo;
40994         uint64_t DECLSPEC_ALIGN(8) timeout;
40995         VkResult result;
40996     } *params = args;
40997     VkSemaphoreWaitInfo pWaitInfo_host;
40998
40999     TRACE("%#x, %#x, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
41000
41001     convert_VkSemaphoreWaitInfo_win32_to_host((const VkSemaphoreWaitInfo32 *)UlongToPtr(params->pWaitInfo), &pWaitInfo_host);
41002     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkWaitSemaphoresKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pWaitInfo_host, params->timeout);
41003     return STATUS_SUCCESS;
41004 }
41005
41006 #ifdef _WIN64
41007 static NTSTATUS thunk64_vkWriteAccelerationStructuresPropertiesKHR(void *args)
41008 {
41009     struct vkWriteAccelerationStructuresPropertiesKHR_params *params = args;
41010
41011     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));
41012
41013     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);
41014     return STATUS_SUCCESS;
41015 }
41016 #endif /* _WIN64 */
41017
41018 static NTSTATUS thunk32_vkWriteAccelerationStructuresPropertiesKHR(void *args)
41019 {
41020     struct
41021     {
41022         PTR32 device;
41023         uint32_t accelerationStructureCount;
41024         PTR32 pAccelerationStructures;
41025         VkQueryType queryType;
41026         PTR32 dataSize;
41027         PTR32 pData;
41028         PTR32 stride;
41029         VkResult result;
41030     } *params = args;
41031
41032     TRACE("%#x, %u, %#x, %#x, 0x%s, %#x, 0x%s\n", params->device, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride));
41033
41034     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkWriteAccelerationStructuresPropertiesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->accelerationStructureCount, (const VkAccelerationStructureKHR *)UlongToPtr(params->pAccelerationStructures), params->queryType, params->dataSize, (void *)UlongToPtr(params->pData), params->stride);
41035     return STATUS_SUCCESS;
41036 }
41037
41038 #ifdef _WIN64
41039 static NTSTATUS thunk64_vkWriteMicromapsPropertiesEXT(void *args)
41040 {
41041     struct vkWriteMicromapsPropertiesEXT_params *params = args;
41042
41043     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));
41044
41045     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);
41046     return STATUS_SUCCESS;
41047 }
41048 #endif /* _WIN64 */
41049
41050 static NTSTATUS thunk32_vkWriteMicromapsPropertiesEXT(void *args)
41051 {
41052     struct
41053     {
41054         PTR32 device;
41055         uint32_t micromapCount;
41056         PTR32 pMicromaps;
41057         VkQueryType queryType;
41058         PTR32 dataSize;
41059         PTR32 pData;
41060         PTR32 stride;
41061         VkResult result;
41062     } *params = args;
41063
41064     TRACE("%#x, %u, %#x, %#x, 0x%s, %#x, 0x%s\n", params->device, params->micromapCount, params->pMicromaps, params->queryType, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride));
41065
41066     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkWriteMicromapsPropertiesEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->micromapCount, (const VkMicromapEXT *)UlongToPtr(params->pMicromaps), params->queryType, params->dataSize, (void *)UlongToPtr(params->pData), params->stride);
41067     return STATUS_SUCCESS;
41068 }
41069
41070 static const char * const vk_device_extensions[] =
41071 {
41072     "VK_AMD_buffer_marker",
41073     "VK_AMD_device_coherent_memory",
41074     "VK_AMD_draw_indirect_count",
41075     "VK_AMD_gcn_shader",
41076     "VK_AMD_gpu_shader_half_float",
41077     "VK_AMD_gpu_shader_int16",
41078     "VK_AMD_memory_overallocation_behavior",
41079     "VK_AMD_mixed_attachment_samples",
41080     "VK_AMD_negative_viewport_height",
41081     "VK_AMD_pipeline_compiler_control",
41082     "VK_AMD_rasterization_order",
41083     "VK_AMD_shader_ballot",
41084     "VK_AMD_shader_core_properties",
41085     "VK_AMD_shader_core_properties2",
41086     "VK_AMD_shader_early_and_late_fragment_tests",
41087     "VK_AMD_shader_explicit_vertex_parameter",
41088     "VK_AMD_shader_fragment_mask",
41089     "VK_AMD_shader_image_load_store_lod",
41090     "VK_AMD_shader_info",
41091     "VK_AMD_shader_trinary_minmax",
41092     "VK_AMD_texture_gather_bias_lod",
41093     "VK_ARM_rasterization_order_attachment_access",
41094     "VK_ARM_shader_core_builtins",
41095     "VK_ARM_shader_core_properties",
41096     "VK_EXT_4444_formats",
41097     "VK_EXT_astc_decode_mode",
41098     "VK_EXT_attachment_feedback_loop_dynamic_state",
41099     "VK_EXT_attachment_feedback_loop_layout",
41100     "VK_EXT_blend_operation_advanced",
41101     "VK_EXT_border_color_swizzle",
41102     "VK_EXT_buffer_device_address",
41103     "VK_EXT_calibrated_timestamps",
41104     "VK_EXT_color_write_enable",
41105     "VK_EXT_conditional_rendering",
41106     "VK_EXT_conservative_rasterization",
41107     "VK_EXT_custom_border_color",
41108     "VK_EXT_debug_marker",
41109     "VK_EXT_depth_clamp_zero_one",
41110     "VK_EXT_depth_clip_control",
41111     "VK_EXT_depth_clip_enable",
41112     "VK_EXT_depth_range_unrestricted",
41113     "VK_EXT_descriptor_buffer",
41114     "VK_EXT_descriptor_indexing",
41115     "VK_EXT_device_address_binding_report",
41116     "VK_EXT_device_fault",
41117     "VK_EXT_discard_rectangles",
41118     "VK_EXT_extended_dynamic_state",
41119     "VK_EXT_extended_dynamic_state2",
41120     "VK_EXT_extended_dynamic_state3",
41121     "VK_EXT_external_memory_host",
41122     "VK_EXT_filter_cubic",
41123     "VK_EXT_fragment_density_map",
41124     "VK_EXT_fragment_density_map2",
41125     "VK_EXT_fragment_shader_interlock",
41126     "VK_EXT_global_priority",
41127     "VK_EXT_global_priority_query",
41128     "VK_EXT_graphics_pipeline_library",
41129     "VK_EXT_hdr_metadata",
41130     "VK_EXT_host_query_reset",
41131     "VK_EXT_image_2d_view_of_3d",
41132     "VK_EXT_image_compression_control",
41133     "VK_EXT_image_compression_control_swapchain",
41134     "VK_EXT_image_robustness",
41135     "VK_EXT_image_sliced_view_of_3d",
41136     "VK_EXT_image_view_min_lod",
41137     "VK_EXT_index_type_uint8",
41138     "VK_EXT_inline_uniform_block",
41139     "VK_EXT_legacy_dithering",
41140     "VK_EXT_line_rasterization",
41141     "VK_EXT_load_store_op_none",
41142     "VK_EXT_memory_budget",
41143     "VK_EXT_memory_priority",
41144     "VK_EXT_mesh_shader",
41145     "VK_EXT_multi_draw",
41146     "VK_EXT_multisampled_render_to_single_sampled",
41147     "VK_EXT_mutable_descriptor_type",
41148     "VK_EXT_non_seamless_cube_map",
41149     "VK_EXT_opacity_micromap",
41150     "VK_EXT_pageable_device_local_memory",
41151     "VK_EXT_pci_bus_info",
41152     "VK_EXT_pipeline_creation_cache_control",
41153     "VK_EXT_pipeline_creation_feedback",
41154     "VK_EXT_pipeline_library_group_handles",
41155     "VK_EXT_pipeline_properties",
41156     "VK_EXT_pipeline_protected_access",
41157     "VK_EXT_pipeline_robustness",
41158     "VK_EXT_post_depth_coverage",
41159     "VK_EXT_primitive_topology_list_restart",
41160     "VK_EXT_primitives_generated_query",
41161     "VK_EXT_private_data",
41162     "VK_EXT_provoking_vertex",
41163     "VK_EXT_queue_family_foreign",
41164     "VK_EXT_rasterization_order_attachment_access",
41165     "VK_EXT_rgba10x6_formats",
41166     "VK_EXT_robustness2",
41167     "VK_EXT_sample_locations",
41168     "VK_EXT_sampler_filter_minmax",
41169     "VK_EXT_scalar_block_layout",
41170     "VK_EXT_separate_stencil_usage",
41171     "VK_EXT_shader_atomic_float",
41172     "VK_EXT_shader_atomic_float2",
41173     "VK_EXT_shader_demote_to_helper_invocation",
41174     "VK_EXT_shader_image_atomic_int64",
41175     "VK_EXT_shader_module_identifier",
41176     "VK_EXT_shader_object",
41177     "VK_EXT_shader_stencil_export",
41178     "VK_EXT_shader_subgroup_ballot",
41179     "VK_EXT_shader_subgroup_vote",
41180     "VK_EXT_shader_tile_image",
41181     "VK_EXT_shader_viewport_index_layer",
41182     "VK_EXT_subgroup_size_control",
41183     "VK_EXT_subpass_merge_feedback",
41184     "VK_EXT_swapchain_maintenance1",
41185     "VK_EXT_texel_buffer_alignment",
41186     "VK_EXT_texture_compression_astc_hdr",
41187     "VK_EXT_tooling_info",
41188     "VK_EXT_transform_feedback",
41189     "VK_EXT_validation_cache",
41190     "VK_EXT_vertex_attribute_divisor",
41191     "VK_EXT_vertex_input_dynamic_state",
41192     "VK_EXT_ycbcr_2plane_444_formats",
41193     "VK_EXT_ycbcr_image_arrays",
41194     "VK_GOOGLE_decorate_string",
41195     "VK_GOOGLE_hlsl_functionality1",
41196     "VK_GOOGLE_user_type",
41197     "VK_HUAWEI_cluster_culling_shader",
41198     "VK_HUAWEI_invocation_mask",
41199     "VK_HUAWEI_subpass_shading",
41200     "VK_IMG_filter_cubic",
41201     "VK_IMG_format_pvrtc",
41202     "VK_INTEL_performance_query",
41203     "VK_INTEL_shader_integer_functions2",
41204     "VK_KHR_16bit_storage",
41205     "VK_KHR_8bit_storage",
41206     "VK_KHR_acceleration_structure",
41207     "VK_KHR_bind_memory2",
41208     "VK_KHR_buffer_device_address",
41209     "VK_KHR_copy_commands2",
41210     "VK_KHR_create_renderpass2",
41211     "VK_KHR_dedicated_allocation",
41212     "VK_KHR_deferred_host_operations",
41213     "VK_KHR_depth_stencil_resolve",
41214     "VK_KHR_descriptor_update_template",
41215     "VK_KHR_device_group",
41216     "VK_KHR_draw_indirect_count",
41217     "VK_KHR_driver_properties",
41218     "VK_KHR_dynamic_rendering",
41219     "VK_KHR_external_fence",
41220     "VK_KHR_external_memory",
41221     "VK_KHR_external_semaphore",
41222     "VK_KHR_format_feature_flags2",
41223     "VK_KHR_fragment_shader_barycentric",
41224     "VK_KHR_fragment_shading_rate",
41225     "VK_KHR_get_memory_requirements2",
41226     "VK_KHR_global_priority",
41227     "VK_KHR_image_format_list",
41228     "VK_KHR_imageless_framebuffer",
41229     "VK_KHR_incremental_present",
41230     "VK_KHR_maintenance1",
41231     "VK_KHR_maintenance2",
41232     "VK_KHR_maintenance3",
41233     "VK_KHR_maintenance4",
41234     "VK_KHR_map_memory2",
41235     "VK_KHR_multiview",
41236     "VK_KHR_performance_query",
41237     "VK_KHR_pipeline_executable_properties",
41238     "VK_KHR_pipeline_library",
41239     "VK_KHR_present_id",
41240     "VK_KHR_present_wait",
41241     "VK_KHR_push_descriptor",
41242     "VK_KHR_ray_query",
41243     "VK_KHR_ray_tracing_maintenance1",
41244     "VK_KHR_ray_tracing_pipeline",
41245     "VK_KHR_ray_tracing_position_fetch",
41246     "VK_KHR_relaxed_block_layout",
41247     "VK_KHR_sampler_mirror_clamp_to_edge",
41248     "VK_KHR_sampler_ycbcr_conversion",
41249     "VK_KHR_separate_depth_stencil_layouts",
41250     "VK_KHR_shader_atomic_int64",
41251     "VK_KHR_shader_clock",
41252     "VK_KHR_shader_draw_parameters",
41253     "VK_KHR_shader_float16_int8",
41254     "VK_KHR_shader_float_controls",
41255     "VK_KHR_shader_integer_dot_product",
41256     "VK_KHR_shader_non_semantic_info",
41257     "VK_KHR_shader_subgroup_extended_types",
41258     "VK_KHR_shader_subgroup_uniform_control_flow",
41259     "VK_KHR_shader_terminate_invocation",
41260     "VK_KHR_spirv_1_4",
41261     "VK_KHR_storage_buffer_storage_class",
41262     "VK_KHR_swapchain",
41263     "VK_KHR_swapchain_mutable_format",
41264     "VK_KHR_synchronization2",
41265     "VK_KHR_timeline_semaphore",
41266     "VK_KHR_uniform_buffer_standard_layout",
41267     "VK_KHR_variable_pointers",
41268     "VK_KHR_vulkan_memory_model",
41269     "VK_KHR_workgroup_memory_explicit_layout",
41270     "VK_KHR_zero_initialize_workgroup_memory",
41271     "VK_NVX_binary_import",
41272     "VK_NVX_image_view_handle",
41273     "VK_NV_clip_space_w_scaling",
41274     "VK_NV_compute_shader_derivatives",
41275     "VK_NV_cooperative_matrix",
41276     "VK_NV_copy_memory_indirect",
41277     "VK_NV_corner_sampled_image",
41278     "VK_NV_coverage_reduction_mode",
41279     "VK_NV_dedicated_allocation",
41280     "VK_NV_dedicated_allocation_image_aliasing",
41281     "VK_NV_device_diagnostic_checkpoints",
41282     "VK_NV_device_diagnostics_config",
41283     "VK_NV_device_generated_commands",
41284     "VK_NV_fill_rectangle",
41285     "VK_NV_fragment_coverage_to_color",
41286     "VK_NV_fragment_shader_barycentric",
41287     "VK_NV_fragment_shading_rate_enums",
41288     "VK_NV_framebuffer_mixed_samples",
41289     "VK_NV_geometry_shader_passthrough",
41290     "VK_NV_glsl_shader",
41291     "VK_NV_inherited_viewport_scissor",
41292     "VK_NV_linear_color_attachment",
41293     "VK_NV_low_latency",
41294     "VK_NV_memory_decompression",
41295     "VK_NV_mesh_shader",
41296     "VK_NV_optical_flow",
41297     "VK_NV_present_barrier",
41298     "VK_NV_ray_tracing",
41299     "VK_NV_ray_tracing_invocation_reorder",
41300     "VK_NV_ray_tracing_motion_blur",
41301     "VK_NV_representative_fragment_test",
41302     "VK_NV_sample_mask_override_coverage",
41303     "VK_NV_scissor_exclusive",
41304     "VK_NV_shader_image_footprint",
41305     "VK_NV_shader_sm_builtins",
41306     "VK_NV_shader_subgroup_partitioned",
41307     "VK_NV_shading_rate_image",
41308     "VK_NV_viewport_array2",
41309     "VK_NV_viewport_swizzle",
41310     "VK_QCOM_fragment_density_map_offset",
41311     "VK_QCOM_image_processing",
41312     "VK_QCOM_multiview_per_view_render_areas",
41313     "VK_QCOM_multiview_per_view_viewports",
41314     "VK_QCOM_render_pass_shader_resolve",
41315     "VK_QCOM_render_pass_store_ops",
41316     "VK_QCOM_render_pass_transform",
41317     "VK_QCOM_rotated_copy_commands",
41318     "VK_QCOM_tile_properties",
41319     "VK_VALVE_descriptor_set_host_mapping",
41320     "VK_VALVE_mutable_descriptor_type",
41321 };
41322
41323 static const char * const vk_instance_extensions[] =
41324 {
41325     "VK_EXT_debug_report",
41326     "VK_EXT_debug_utils",
41327     "VK_EXT_surface_maintenance1",
41328     "VK_EXT_swapchain_colorspace",
41329     "VK_EXT_validation_features",
41330     "VK_EXT_validation_flags",
41331     "VK_KHR_device_group_creation",
41332     "VK_KHR_external_fence_capabilities",
41333     "VK_KHR_external_memory_capabilities",
41334     "VK_KHR_external_semaphore_capabilities",
41335     "VK_KHR_get_physical_device_properties2",
41336     "VK_KHR_get_surface_capabilities2",
41337     "VK_KHR_portability_enumeration",
41338     "VK_KHR_surface",
41339     "VK_KHR_win32_surface",
41340 };
41341
41342 BOOL wine_vk_device_extension_supported(const char *name)
41343 {
41344     unsigned int i;
41345     for (i = 0; i < ARRAY_SIZE(vk_device_extensions); i++)
41346     {
41347         if (strcmp(vk_device_extensions[i], name) == 0)
41348             return TRUE;
41349     }
41350     return FALSE;
41351 }
41352
41353 BOOL wine_vk_instance_extension_supported(const char *name)
41354 {
41355     unsigned int i;
41356     for (i = 0; i < ARRAY_SIZE(vk_instance_extensions); i++)
41357     {
41358         if (strcmp(vk_instance_extensions[i], name) == 0)
41359             return TRUE;
41360     }
41361     return FALSE;
41362 }
41363
41364 BOOL wine_vk_is_type_wrapped(VkObjectType type)
41365 {
41366     return FALSE ||
41367         type == VK_OBJECT_TYPE_COMMAND_BUFFER ||
41368         type == VK_OBJECT_TYPE_COMMAND_POOL ||
41369         type == VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT ||
41370         type == VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT ||
41371         type == VK_OBJECT_TYPE_DEVICE ||
41372         type == VK_OBJECT_TYPE_DEVICE_MEMORY ||
41373         type == VK_OBJECT_TYPE_INSTANCE ||
41374         type == VK_OBJECT_TYPE_PHYSICAL_DEVICE ||
41375         type == VK_OBJECT_TYPE_QUEUE ||
41376         type == VK_OBJECT_TYPE_SURFACE_KHR;
41377 }
41378
41379 #ifdef _WIN64
41380
41381 const unixlib_entry_t __wine_unix_call_funcs[] =
41382 {
41383     init_vulkan,
41384     vk_is_available_instance_function,
41385     vk_is_available_device_function,
41386     thunk64_vkAcquireNextImage2KHR,
41387     thunk64_vkAcquireNextImageKHR,
41388     thunk64_vkAcquirePerformanceConfigurationINTEL,
41389     thunk64_vkAcquireProfilingLockKHR,
41390     thunk64_vkAllocateCommandBuffers,
41391     thunk64_vkAllocateDescriptorSets,
41392     thunk64_vkAllocateMemory,
41393     thunk64_vkBeginCommandBuffer,
41394     thunk64_vkBindAccelerationStructureMemoryNV,
41395     thunk64_vkBindBufferMemory,
41396     thunk64_vkBindBufferMemory2,
41397     thunk64_vkBindBufferMemory2KHR,
41398     thunk64_vkBindImageMemory,
41399     thunk64_vkBindImageMemory2,
41400     thunk64_vkBindImageMemory2KHR,
41401     thunk64_vkBindOpticalFlowSessionImageNV,
41402     thunk64_vkBuildAccelerationStructuresKHR,
41403     thunk64_vkBuildMicromapsEXT,
41404     (void *)thunk64_vkCmdBeginConditionalRenderingEXT,
41405     (void *)thunk64_vkCmdBeginDebugUtilsLabelEXT,
41406     (void *)thunk64_vkCmdBeginQuery,
41407     (void *)thunk64_vkCmdBeginQueryIndexedEXT,
41408     (void *)thunk64_vkCmdBeginRenderPass,
41409     (void *)thunk64_vkCmdBeginRenderPass2,
41410     (void *)thunk64_vkCmdBeginRenderPass2KHR,
41411     (void *)thunk64_vkCmdBeginRendering,
41412     (void *)thunk64_vkCmdBeginRenderingKHR,
41413     (void *)thunk64_vkCmdBeginTransformFeedbackEXT,
41414     (void *)thunk64_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,
41415     (void *)thunk64_vkCmdBindDescriptorBuffersEXT,
41416     (void *)thunk64_vkCmdBindDescriptorSets,
41417     (void *)thunk64_vkCmdBindIndexBuffer,
41418     (void *)thunk64_vkCmdBindInvocationMaskHUAWEI,
41419     (void *)thunk64_vkCmdBindPipeline,
41420     (void *)thunk64_vkCmdBindPipelineShaderGroupNV,
41421     (void *)thunk64_vkCmdBindShadersEXT,
41422     (void *)thunk64_vkCmdBindShadingRateImageNV,
41423     (void *)thunk64_vkCmdBindTransformFeedbackBuffersEXT,
41424     (void *)thunk64_vkCmdBindVertexBuffers,
41425     (void *)thunk64_vkCmdBindVertexBuffers2,
41426     (void *)thunk64_vkCmdBindVertexBuffers2EXT,
41427     (void *)thunk64_vkCmdBlitImage,
41428     (void *)thunk64_vkCmdBlitImage2,
41429     (void *)thunk64_vkCmdBlitImage2KHR,
41430     (void *)thunk64_vkCmdBuildAccelerationStructureNV,
41431     (void *)thunk64_vkCmdBuildAccelerationStructuresIndirectKHR,
41432     (void *)thunk64_vkCmdBuildAccelerationStructuresKHR,
41433     (void *)thunk64_vkCmdBuildMicromapsEXT,
41434     (void *)thunk64_vkCmdClearAttachments,
41435     (void *)thunk64_vkCmdClearColorImage,
41436     (void *)thunk64_vkCmdClearDepthStencilImage,
41437     (void *)thunk64_vkCmdCopyAccelerationStructureKHR,
41438     (void *)thunk64_vkCmdCopyAccelerationStructureNV,
41439     (void *)thunk64_vkCmdCopyAccelerationStructureToMemoryKHR,
41440     (void *)thunk64_vkCmdCopyBuffer,
41441     (void *)thunk64_vkCmdCopyBuffer2,
41442     (void *)thunk64_vkCmdCopyBuffer2KHR,
41443     (void *)thunk64_vkCmdCopyBufferToImage,
41444     (void *)thunk64_vkCmdCopyBufferToImage2,
41445     (void *)thunk64_vkCmdCopyBufferToImage2KHR,
41446     (void *)thunk64_vkCmdCopyImage,
41447     (void *)thunk64_vkCmdCopyImage2,
41448     (void *)thunk64_vkCmdCopyImage2KHR,
41449     (void *)thunk64_vkCmdCopyImageToBuffer,
41450     (void *)thunk64_vkCmdCopyImageToBuffer2,
41451     (void *)thunk64_vkCmdCopyImageToBuffer2KHR,
41452     (void *)thunk64_vkCmdCopyMemoryIndirectNV,
41453     (void *)thunk64_vkCmdCopyMemoryToAccelerationStructureKHR,
41454     (void *)thunk64_vkCmdCopyMemoryToImageIndirectNV,
41455     (void *)thunk64_vkCmdCopyMemoryToMicromapEXT,
41456     (void *)thunk64_vkCmdCopyMicromapEXT,
41457     (void *)thunk64_vkCmdCopyMicromapToMemoryEXT,
41458     (void *)thunk64_vkCmdCopyQueryPoolResults,
41459     (void *)thunk64_vkCmdCuLaunchKernelNVX,
41460     (void *)thunk64_vkCmdDebugMarkerBeginEXT,
41461     (void *)thunk64_vkCmdDebugMarkerEndEXT,
41462     (void *)thunk64_vkCmdDebugMarkerInsertEXT,
41463     (void *)thunk64_vkCmdDecompressMemoryIndirectCountNV,
41464     (void *)thunk64_vkCmdDecompressMemoryNV,
41465     (void *)thunk64_vkCmdDispatch,
41466     (void *)thunk64_vkCmdDispatchBase,
41467     (void *)thunk64_vkCmdDispatchBaseKHR,
41468     (void *)thunk64_vkCmdDispatchIndirect,
41469     (void *)thunk64_vkCmdDraw,
41470     (void *)thunk64_vkCmdDrawClusterHUAWEI,
41471     (void *)thunk64_vkCmdDrawClusterIndirectHUAWEI,
41472     (void *)thunk64_vkCmdDrawIndexed,
41473     (void *)thunk64_vkCmdDrawIndexedIndirect,
41474     (void *)thunk64_vkCmdDrawIndexedIndirectCount,
41475     (void *)thunk64_vkCmdDrawIndexedIndirectCountAMD,
41476     (void *)thunk64_vkCmdDrawIndexedIndirectCountKHR,
41477     (void *)thunk64_vkCmdDrawIndirect,
41478     (void *)thunk64_vkCmdDrawIndirectByteCountEXT,
41479     (void *)thunk64_vkCmdDrawIndirectCount,
41480     (void *)thunk64_vkCmdDrawIndirectCountAMD,
41481     (void *)thunk64_vkCmdDrawIndirectCountKHR,
41482     (void *)thunk64_vkCmdDrawMeshTasksEXT,
41483     (void *)thunk64_vkCmdDrawMeshTasksIndirectCountEXT,
41484     (void *)thunk64_vkCmdDrawMeshTasksIndirectCountNV,
41485     (void *)thunk64_vkCmdDrawMeshTasksIndirectEXT,
41486     (void *)thunk64_vkCmdDrawMeshTasksIndirectNV,
41487     (void *)thunk64_vkCmdDrawMeshTasksNV,
41488     (void *)thunk64_vkCmdDrawMultiEXT,
41489     (void *)thunk64_vkCmdDrawMultiIndexedEXT,
41490     (void *)thunk64_vkCmdEndConditionalRenderingEXT,
41491     (void *)thunk64_vkCmdEndDebugUtilsLabelEXT,
41492     (void *)thunk64_vkCmdEndQuery,
41493     (void *)thunk64_vkCmdEndQueryIndexedEXT,
41494     (void *)thunk64_vkCmdEndRenderPass,
41495     (void *)thunk64_vkCmdEndRenderPass2,
41496     (void *)thunk64_vkCmdEndRenderPass2KHR,
41497     (void *)thunk64_vkCmdEndRendering,
41498     (void *)thunk64_vkCmdEndRenderingKHR,
41499     (void *)thunk64_vkCmdEndTransformFeedbackEXT,
41500     (void *)thunk64_vkCmdExecuteCommands,
41501     (void *)thunk64_vkCmdExecuteGeneratedCommandsNV,
41502     (void *)thunk64_vkCmdFillBuffer,
41503     (void *)thunk64_vkCmdInsertDebugUtilsLabelEXT,
41504     (void *)thunk64_vkCmdNextSubpass,
41505     (void *)thunk64_vkCmdNextSubpass2,
41506     (void *)thunk64_vkCmdNextSubpass2KHR,
41507     (void *)thunk64_vkCmdOpticalFlowExecuteNV,
41508     (void *)thunk64_vkCmdPipelineBarrier,
41509     (void *)thunk64_vkCmdPipelineBarrier2,
41510     (void *)thunk64_vkCmdPipelineBarrier2KHR,
41511     (void *)thunk64_vkCmdPreprocessGeneratedCommandsNV,
41512     (void *)thunk64_vkCmdPushConstants,
41513     (void *)thunk64_vkCmdPushDescriptorSetKHR,
41514     (void *)thunk64_vkCmdPushDescriptorSetWithTemplateKHR,
41515     (void *)thunk64_vkCmdResetEvent,
41516     (void *)thunk64_vkCmdResetEvent2,
41517     (void *)thunk64_vkCmdResetEvent2KHR,
41518     (void *)thunk64_vkCmdResetQueryPool,
41519     (void *)thunk64_vkCmdResolveImage,
41520     (void *)thunk64_vkCmdResolveImage2,
41521     (void *)thunk64_vkCmdResolveImage2KHR,
41522     (void *)thunk64_vkCmdSetAlphaToCoverageEnableEXT,
41523     (void *)thunk64_vkCmdSetAlphaToOneEnableEXT,
41524     (void *)thunk64_vkCmdSetAttachmentFeedbackLoopEnableEXT,
41525     (void *)thunk64_vkCmdSetBlendConstants,
41526     (void *)thunk64_vkCmdSetCheckpointNV,
41527     (void *)thunk64_vkCmdSetCoarseSampleOrderNV,
41528     (void *)thunk64_vkCmdSetColorBlendAdvancedEXT,
41529     (void *)thunk64_vkCmdSetColorBlendEnableEXT,
41530     (void *)thunk64_vkCmdSetColorBlendEquationEXT,
41531     (void *)thunk64_vkCmdSetColorWriteEnableEXT,
41532     (void *)thunk64_vkCmdSetColorWriteMaskEXT,
41533     (void *)thunk64_vkCmdSetConservativeRasterizationModeEXT,
41534     (void *)thunk64_vkCmdSetCoverageModulationModeNV,
41535     (void *)thunk64_vkCmdSetCoverageModulationTableEnableNV,
41536     (void *)thunk64_vkCmdSetCoverageModulationTableNV,
41537     (void *)thunk64_vkCmdSetCoverageReductionModeNV,
41538     (void *)thunk64_vkCmdSetCoverageToColorEnableNV,
41539     (void *)thunk64_vkCmdSetCoverageToColorLocationNV,
41540     (void *)thunk64_vkCmdSetCullMode,
41541     (void *)thunk64_vkCmdSetCullModeEXT,
41542     (void *)thunk64_vkCmdSetDepthBias,
41543     (void *)thunk64_vkCmdSetDepthBiasEnable,
41544     (void *)thunk64_vkCmdSetDepthBiasEnableEXT,
41545     (void *)thunk64_vkCmdSetDepthBounds,
41546     (void *)thunk64_vkCmdSetDepthBoundsTestEnable,
41547     (void *)thunk64_vkCmdSetDepthBoundsTestEnableEXT,
41548     (void *)thunk64_vkCmdSetDepthClampEnableEXT,
41549     (void *)thunk64_vkCmdSetDepthClipEnableEXT,
41550     (void *)thunk64_vkCmdSetDepthClipNegativeOneToOneEXT,
41551     (void *)thunk64_vkCmdSetDepthCompareOp,
41552     (void *)thunk64_vkCmdSetDepthCompareOpEXT,
41553     (void *)thunk64_vkCmdSetDepthTestEnable,
41554     (void *)thunk64_vkCmdSetDepthTestEnableEXT,
41555     (void *)thunk64_vkCmdSetDepthWriteEnable,
41556     (void *)thunk64_vkCmdSetDepthWriteEnableEXT,
41557     (void *)thunk64_vkCmdSetDescriptorBufferOffsetsEXT,
41558     (void *)thunk64_vkCmdSetDeviceMask,
41559     (void *)thunk64_vkCmdSetDeviceMaskKHR,
41560     (void *)thunk64_vkCmdSetDiscardRectangleEXT,
41561     (void *)thunk64_vkCmdSetDiscardRectangleEnableEXT,
41562     (void *)thunk64_vkCmdSetDiscardRectangleModeEXT,
41563     (void *)thunk64_vkCmdSetEvent,
41564     (void *)thunk64_vkCmdSetEvent2,
41565     (void *)thunk64_vkCmdSetEvent2KHR,
41566     (void *)thunk64_vkCmdSetExclusiveScissorEnableNV,
41567     (void *)thunk64_vkCmdSetExclusiveScissorNV,
41568     (void *)thunk64_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
41569     (void *)thunk64_vkCmdSetFragmentShadingRateEnumNV,
41570     (void *)thunk64_vkCmdSetFragmentShadingRateKHR,
41571     (void *)thunk64_vkCmdSetFrontFace,
41572     (void *)thunk64_vkCmdSetFrontFaceEXT,
41573     (void *)thunk64_vkCmdSetLineRasterizationModeEXT,
41574     (void *)thunk64_vkCmdSetLineStippleEXT,
41575     (void *)thunk64_vkCmdSetLineStippleEnableEXT,
41576     (void *)thunk64_vkCmdSetLineWidth,
41577     (void *)thunk64_vkCmdSetLogicOpEXT,
41578     (void *)thunk64_vkCmdSetLogicOpEnableEXT,
41579     (void *)thunk64_vkCmdSetPatchControlPointsEXT,
41580     thunk64_vkCmdSetPerformanceMarkerINTEL,
41581     thunk64_vkCmdSetPerformanceOverrideINTEL,
41582     thunk64_vkCmdSetPerformanceStreamMarkerINTEL,
41583     (void *)thunk64_vkCmdSetPolygonModeEXT,
41584     (void *)thunk64_vkCmdSetPrimitiveRestartEnable,
41585     (void *)thunk64_vkCmdSetPrimitiveRestartEnableEXT,
41586     (void *)thunk64_vkCmdSetPrimitiveTopology,
41587     (void *)thunk64_vkCmdSetPrimitiveTopologyEXT,
41588     (void *)thunk64_vkCmdSetProvokingVertexModeEXT,
41589     (void *)thunk64_vkCmdSetRasterizationSamplesEXT,
41590     (void *)thunk64_vkCmdSetRasterizationStreamEXT,
41591     (void *)thunk64_vkCmdSetRasterizerDiscardEnable,
41592     (void *)thunk64_vkCmdSetRasterizerDiscardEnableEXT,
41593     (void *)thunk64_vkCmdSetRayTracingPipelineStackSizeKHR,
41594     (void *)thunk64_vkCmdSetRepresentativeFragmentTestEnableNV,
41595     (void *)thunk64_vkCmdSetSampleLocationsEXT,
41596     (void *)thunk64_vkCmdSetSampleLocationsEnableEXT,
41597     (void *)thunk64_vkCmdSetSampleMaskEXT,
41598     (void *)thunk64_vkCmdSetScissor,
41599     (void *)thunk64_vkCmdSetScissorWithCount,
41600     (void *)thunk64_vkCmdSetScissorWithCountEXT,
41601     (void *)thunk64_vkCmdSetShadingRateImageEnableNV,
41602     (void *)thunk64_vkCmdSetStencilCompareMask,
41603     (void *)thunk64_vkCmdSetStencilOp,
41604     (void *)thunk64_vkCmdSetStencilOpEXT,
41605     (void *)thunk64_vkCmdSetStencilReference,
41606     (void *)thunk64_vkCmdSetStencilTestEnable,
41607     (void *)thunk64_vkCmdSetStencilTestEnableEXT,
41608     (void *)thunk64_vkCmdSetStencilWriteMask,
41609     (void *)thunk64_vkCmdSetTessellationDomainOriginEXT,
41610     (void *)thunk64_vkCmdSetVertexInputEXT,
41611     (void *)thunk64_vkCmdSetViewport,
41612     (void *)thunk64_vkCmdSetViewportShadingRatePaletteNV,
41613     (void *)thunk64_vkCmdSetViewportSwizzleNV,
41614     (void *)thunk64_vkCmdSetViewportWScalingEnableNV,
41615     (void *)thunk64_vkCmdSetViewportWScalingNV,
41616     (void *)thunk64_vkCmdSetViewportWithCount,
41617     (void *)thunk64_vkCmdSetViewportWithCountEXT,
41618     (void *)thunk64_vkCmdSubpassShadingHUAWEI,
41619     (void *)thunk64_vkCmdTraceRaysIndirect2KHR,
41620     (void *)thunk64_vkCmdTraceRaysIndirectKHR,
41621     (void *)thunk64_vkCmdTraceRaysKHR,
41622     (void *)thunk64_vkCmdTraceRaysNV,
41623     (void *)thunk64_vkCmdUpdateBuffer,
41624     (void *)thunk64_vkCmdWaitEvents,
41625     (void *)thunk64_vkCmdWaitEvents2,
41626     (void *)thunk64_vkCmdWaitEvents2KHR,
41627     (void *)thunk64_vkCmdWriteAccelerationStructuresPropertiesKHR,
41628     (void *)thunk64_vkCmdWriteAccelerationStructuresPropertiesNV,
41629     (void *)thunk64_vkCmdWriteBufferMarker2AMD,
41630     (void *)thunk64_vkCmdWriteBufferMarkerAMD,
41631     (void *)thunk64_vkCmdWriteMicromapsPropertiesEXT,
41632     (void *)thunk64_vkCmdWriteTimestamp,
41633     (void *)thunk64_vkCmdWriteTimestamp2,
41634     (void *)thunk64_vkCmdWriteTimestamp2KHR,
41635     thunk64_vkCompileDeferredNV,
41636     thunk64_vkCopyAccelerationStructureKHR,
41637     thunk64_vkCopyAccelerationStructureToMemoryKHR,
41638     thunk64_vkCopyMemoryToAccelerationStructureKHR,
41639     thunk64_vkCopyMemoryToMicromapEXT,
41640     thunk64_vkCopyMicromapEXT,
41641     thunk64_vkCopyMicromapToMemoryEXT,
41642     thunk64_vkCreateAccelerationStructureKHR,
41643     thunk64_vkCreateAccelerationStructureNV,
41644     thunk64_vkCreateBuffer,
41645     thunk64_vkCreateBufferView,
41646     thunk64_vkCreateCommandPool,
41647     thunk64_vkCreateComputePipelines,
41648     thunk64_vkCreateCuFunctionNVX,
41649     thunk64_vkCreateCuModuleNVX,
41650     thunk64_vkCreateDebugReportCallbackEXT,
41651     thunk64_vkCreateDebugUtilsMessengerEXT,
41652     thunk64_vkCreateDeferredOperationKHR,
41653     thunk64_vkCreateDescriptorPool,
41654     thunk64_vkCreateDescriptorSetLayout,
41655     thunk64_vkCreateDescriptorUpdateTemplate,
41656     thunk64_vkCreateDescriptorUpdateTemplateKHR,
41657     thunk64_vkCreateDevice,
41658     thunk64_vkCreateEvent,
41659     thunk64_vkCreateFence,
41660     thunk64_vkCreateFramebuffer,
41661     thunk64_vkCreateGraphicsPipelines,
41662     thunk64_vkCreateImage,
41663     thunk64_vkCreateImageView,
41664     thunk64_vkCreateIndirectCommandsLayoutNV,
41665     thunk64_vkCreateInstance,
41666     thunk64_vkCreateMicromapEXT,
41667     thunk64_vkCreateOpticalFlowSessionNV,
41668     thunk64_vkCreatePipelineCache,
41669     thunk64_vkCreatePipelineLayout,
41670     thunk64_vkCreatePrivateDataSlot,
41671     thunk64_vkCreatePrivateDataSlotEXT,
41672     thunk64_vkCreateQueryPool,
41673     thunk64_vkCreateRayTracingPipelinesKHR,
41674     thunk64_vkCreateRayTracingPipelinesNV,
41675     thunk64_vkCreateRenderPass,
41676     thunk64_vkCreateRenderPass2,
41677     thunk64_vkCreateRenderPass2KHR,
41678     thunk64_vkCreateSampler,
41679     thunk64_vkCreateSamplerYcbcrConversion,
41680     thunk64_vkCreateSamplerYcbcrConversionKHR,
41681     thunk64_vkCreateSemaphore,
41682     thunk64_vkCreateShaderModule,
41683     thunk64_vkCreateShadersEXT,
41684     thunk64_vkCreateSwapchainKHR,
41685     thunk64_vkCreateValidationCacheEXT,
41686     thunk64_vkCreateWin32SurfaceKHR,
41687     thunk64_vkDebugMarkerSetObjectNameEXT,
41688     thunk64_vkDebugMarkerSetObjectTagEXT,
41689     thunk64_vkDebugReportMessageEXT,
41690     thunk64_vkDeferredOperationJoinKHR,
41691     thunk64_vkDestroyAccelerationStructureKHR,
41692     thunk64_vkDestroyAccelerationStructureNV,
41693     thunk64_vkDestroyBuffer,
41694     thunk64_vkDestroyBufferView,
41695     thunk64_vkDestroyCommandPool,
41696     thunk64_vkDestroyCuFunctionNVX,
41697     thunk64_vkDestroyCuModuleNVX,
41698     thunk64_vkDestroyDebugReportCallbackEXT,
41699     thunk64_vkDestroyDebugUtilsMessengerEXT,
41700     thunk64_vkDestroyDeferredOperationKHR,
41701     thunk64_vkDestroyDescriptorPool,
41702     thunk64_vkDestroyDescriptorSetLayout,
41703     thunk64_vkDestroyDescriptorUpdateTemplate,
41704     thunk64_vkDestroyDescriptorUpdateTemplateKHR,
41705     thunk64_vkDestroyDevice,
41706     thunk64_vkDestroyEvent,
41707     thunk64_vkDestroyFence,
41708     thunk64_vkDestroyFramebuffer,
41709     thunk64_vkDestroyImage,
41710     thunk64_vkDestroyImageView,
41711     thunk64_vkDestroyIndirectCommandsLayoutNV,
41712     thunk64_vkDestroyInstance,
41713     thunk64_vkDestroyMicromapEXT,
41714     thunk64_vkDestroyOpticalFlowSessionNV,
41715     thunk64_vkDestroyPipeline,
41716     thunk64_vkDestroyPipelineCache,
41717     thunk64_vkDestroyPipelineLayout,
41718     thunk64_vkDestroyPrivateDataSlot,
41719     thunk64_vkDestroyPrivateDataSlotEXT,
41720     thunk64_vkDestroyQueryPool,
41721     thunk64_vkDestroyRenderPass,
41722     thunk64_vkDestroySampler,
41723     thunk64_vkDestroySamplerYcbcrConversion,
41724     thunk64_vkDestroySamplerYcbcrConversionKHR,
41725     thunk64_vkDestroySemaphore,
41726     thunk64_vkDestroyShaderEXT,
41727     thunk64_vkDestroyShaderModule,
41728     thunk64_vkDestroySurfaceKHR,
41729     thunk64_vkDestroySwapchainKHR,
41730     thunk64_vkDestroyValidationCacheEXT,
41731     thunk64_vkDeviceWaitIdle,
41732     thunk64_vkEndCommandBuffer,
41733     thunk64_vkEnumerateDeviceExtensionProperties,
41734     thunk64_vkEnumerateDeviceLayerProperties,
41735     thunk64_vkEnumerateInstanceExtensionProperties,
41736     thunk64_vkEnumerateInstanceVersion,
41737     thunk64_vkEnumeratePhysicalDeviceGroups,
41738     thunk64_vkEnumeratePhysicalDeviceGroupsKHR,
41739     thunk64_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
41740     thunk64_vkEnumeratePhysicalDevices,
41741     thunk64_vkFlushMappedMemoryRanges,
41742     thunk64_vkFreeCommandBuffers,
41743     thunk64_vkFreeDescriptorSets,
41744     thunk64_vkFreeMemory,
41745     thunk64_vkGetAccelerationStructureBuildSizesKHR,
41746     thunk64_vkGetAccelerationStructureDeviceAddressKHR,
41747     thunk64_vkGetAccelerationStructureHandleNV,
41748     thunk64_vkGetAccelerationStructureMemoryRequirementsNV,
41749     thunk64_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT,
41750     thunk64_vkGetBufferDeviceAddress,
41751     thunk64_vkGetBufferDeviceAddressEXT,
41752     thunk64_vkGetBufferDeviceAddressKHR,
41753     thunk64_vkGetBufferMemoryRequirements,
41754     thunk64_vkGetBufferMemoryRequirements2,
41755     thunk64_vkGetBufferMemoryRequirements2KHR,
41756     thunk64_vkGetBufferOpaqueCaptureAddress,
41757     thunk64_vkGetBufferOpaqueCaptureAddressKHR,
41758     thunk64_vkGetBufferOpaqueCaptureDescriptorDataEXT,
41759     thunk64_vkGetCalibratedTimestampsEXT,
41760     thunk64_vkGetDeferredOperationMaxConcurrencyKHR,
41761     thunk64_vkGetDeferredOperationResultKHR,
41762     (void *)thunk64_vkGetDescriptorEXT,
41763     thunk64_vkGetDescriptorSetHostMappingVALVE,
41764     thunk64_vkGetDescriptorSetLayoutBindingOffsetEXT,
41765     thunk64_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
41766     thunk64_vkGetDescriptorSetLayoutSizeEXT,
41767     thunk64_vkGetDescriptorSetLayoutSupport,
41768     thunk64_vkGetDescriptorSetLayoutSupportKHR,
41769     thunk64_vkGetDeviceAccelerationStructureCompatibilityKHR,
41770     thunk64_vkGetDeviceBufferMemoryRequirements,
41771     thunk64_vkGetDeviceBufferMemoryRequirementsKHR,
41772     thunk64_vkGetDeviceFaultInfoEXT,
41773     thunk64_vkGetDeviceGroupPeerMemoryFeatures,
41774     thunk64_vkGetDeviceGroupPeerMemoryFeaturesKHR,
41775     thunk64_vkGetDeviceGroupPresentCapabilitiesKHR,
41776     thunk64_vkGetDeviceGroupSurfacePresentModesKHR,
41777     thunk64_vkGetDeviceImageMemoryRequirements,
41778     thunk64_vkGetDeviceImageMemoryRequirementsKHR,
41779     thunk64_vkGetDeviceImageSparseMemoryRequirements,
41780     thunk64_vkGetDeviceImageSparseMemoryRequirementsKHR,
41781     thunk64_vkGetDeviceMemoryCommitment,
41782     thunk64_vkGetDeviceMemoryOpaqueCaptureAddress,
41783     thunk64_vkGetDeviceMemoryOpaqueCaptureAddressKHR,
41784     thunk64_vkGetDeviceMicromapCompatibilityEXT,
41785     thunk64_vkGetDeviceQueue,
41786     thunk64_vkGetDeviceQueue2,
41787     thunk64_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
41788     thunk64_vkGetDynamicRenderingTilePropertiesQCOM,
41789     thunk64_vkGetEventStatus,
41790     thunk64_vkGetFenceStatus,
41791     thunk64_vkGetFramebufferTilePropertiesQCOM,
41792     thunk64_vkGetGeneratedCommandsMemoryRequirementsNV,
41793     thunk64_vkGetImageMemoryRequirements,
41794     thunk64_vkGetImageMemoryRequirements2,
41795     thunk64_vkGetImageMemoryRequirements2KHR,
41796     thunk64_vkGetImageOpaqueCaptureDescriptorDataEXT,
41797     thunk64_vkGetImageSparseMemoryRequirements,
41798     thunk64_vkGetImageSparseMemoryRequirements2,
41799     thunk64_vkGetImageSparseMemoryRequirements2KHR,
41800     thunk64_vkGetImageSubresourceLayout,
41801     thunk64_vkGetImageSubresourceLayout2EXT,
41802     thunk64_vkGetImageViewAddressNVX,
41803     thunk64_vkGetImageViewHandleNVX,
41804     thunk64_vkGetImageViewOpaqueCaptureDescriptorDataEXT,
41805     thunk64_vkGetMemoryHostPointerPropertiesEXT,
41806     thunk64_vkGetMicromapBuildSizesEXT,
41807     thunk64_vkGetPerformanceParameterINTEL,
41808     thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
41809     thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
41810     thunk64_vkGetPhysicalDeviceExternalBufferProperties,
41811     thunk64_vkGetPhysicalDeviceExternalBufferPropertiesKHR,
41812     thunk64_vkGetPhysicalDeviceExternalFenceProperties,
41813     thunk64_vkGetPhysicalDeviceExternalFencePropertiesKHR,
41814     thunk64_vkGetPhysicalDeviceExternalSemaphoreProperties,
41815     thunk64_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,
41816     thunk64_vkGetPhysicalDeviceFeatures,
41817     thunk64_vkGetPhysicalDeviceFeatures2,
41818     thunk64_vkGetPhysicalDeviceFeatures2KHR,
41819     thunk64_vkGetPhysicalDeviceFormatProperties,
41820     thunk64_vkGetPhysicalDeviceFormatProperties2,
41821     thunk64_vkGetPhysicalDeviceFormatProperties2KHR,
41822     thunk64_vkGetPhysicalDeviceFragmentShadingRatesKHR,
41823     thunk64_vkGetPhysicalDeviceImageFormatProperties,
41824     thunk64_vkGetPhysicalDeviceImageFormatProperties2,
41825     thunk64_vkGetPhysicalDeviceImageFormatProperties2KHR,
41826     thunk64_vkGetPhysicalDeviceMemoryProperties,
41827     thunk64_vkGetPhysicalDeviceMemoryProperties2,
41828     thunk64_vkGetPhysicalDeviceMemoryProperties2KHR,
41829     thunk64_vkGetPhysicalDeviceMultisamplePropertiesEXT,
41830     thunk64_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
41831     thunk64_vkGetPhysicalDevicePresentRectanglesKHR,
41832     thunk64_vkGetPhysicalDeviceProperties,
41833     thunk64_vkGetPhysicalDeviceProperties2,
41834     thunk64_vkGetPhysicalDeviceProperties2KHR,
41835     thunk64_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
41836     thunk64_vkGetPhysicalDeviceQueueFamilyProperties,
41837     thunk64_vkGetPhysicalDeviceQueueFamilyProperties2,
41838     thunk64_vkGetPhysicalDeviceQueueFamilyProperties2KHR,
41839     thunk64_vkGetPhysicalDeviceSparseImageFormatProperties,
41840     thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2,
41841     thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,
41842     thunk64_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
41843     thunk64_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
41844     thunk64_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
41845     thunk64_vkGetPhysicalDeviceSurfaceFormats2KHR,
41846     thunk64_vkGetPhysicalDeviceSurfaceFormatsKHR,
41847     thunk64_vkGetPhysicalDeviceSurfacePresentModesKHR,
41848     thunk64_vkGetPhysicalDeviceSurfaceSupportKHR,
41849     thunk64_vkGetPhysicalDeviceToolProperties,
41850     thunk64_vkGetPhysicalDeviceToolPropertiesEXT,
41851     thunk64_vkGetPhysicalDeviceWin32PresentationSupportKHR,
41852     thunk64_vkGetPipelineCacheData,
41853     thunk64_vkGetPipelineExecutableInternalRepresentationsKHR,
41854     thunk64_vkGetPipelineExecutablePropertiesKHR,
41855     thunk64_vkGetPipelineExecutableStatisticsKHR,
41856     thunk64_vkGetPipelinePropertiesEXT,
41857     thunk64_vkGetPrivateData,
41858     thunk64_vkGetPrivateDataEXT,
41859     thunk64_vkGetQueryPoolResults,
41860     thunk64_vkGetQueueCheckpointData2NV,
41861     thunk64_vkGetQueueCheckpointDataNV,
41862     thunk64_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
41863     thunk64_vkGetRayTracingShaderGroupHandlesKHR,
41864     thunk64_vkGetRayTracingShaderGroupHandlesNV,
41865     thunk64_vkGetRayTracingShaderGroupStackSizeKHR,
41866     thunk64_vkGetRenderAreaGranularity,
41867     thunk64_vkGetSamplerOpaqueCaptureDescriptorDataEXT,
41868     thunk64_vkGetSemaphoreCounterValue,
41869     thunk64_vkGetSemaphoreCounterValueKHR,
41870     thunk64_vkGetShaderBinaryDataEXT,
41871     thunk64_vkGetShaderInfoAMD,
41872     thunk64_vkGetShaderModuleCreateInfoIdentifierEXT,
41873     thunk64_vkGetShaderModuleIdentifierEXT,
41874     thunk64_vkGetSwapchainImagesKHR,
41875     thunk64_vkGetValidationCacheDataEXT,
41876     thunk64_vkInitializePerformanceApiINTEL,
41877     thunk64_vkInvalidateMappedMemoryRanges,
41878     thunk64_vkMapMemory,
41879     thunk64_vkMapMemory2KHR,
41880     thunk64_vkMergePipelineCaches,
41881     thunk64_vkMergeValidationCachesEXT,
41882     thunk64_vkQueueBeginDebugUtilsLabelEXT,
41883     thunk64_vkQueueBindSparse,
41884     thunk64_vkQueueEndDebugUtilsLabelEXT,
41885     thunk64_vkQueueInsertDebugUtilsLabelEXT,
41886     thunk64_vkQueuePresentKHR,
41887     thunk64_vkQueueSetPerformanceConfigurationINTEL,
41888     thunk64_vkQueueSubmit,
41889     thunk64_vkQueueSubmit2,
41890     thunk64_vkQueueSubmit2KHR,
41891     thunk64_vkQueueWaitIdle,
41892     thunk64_vkReleasePerformanceConfigurationINTEL,
41893     thunk64_vkReleaseProfilingLockKHR,
41894     thunk64_vkReleaseSwapchainImagesEXT,
41895     thunk64_vkResetCommandBuffer,
41896     thunk64_vkResetCommandPool,
41897     thunk64_vkResetDescriptorPool,
41898     thunk64_vkResetEvent,
41899     thunk64_vkResetFences,
41900     thunk64_vkResetQueryPool,
41901     thunk64_vkResetQueryPoolEXT,
41902     thunk64_vkSetDebugUtilsObjectNameEXT,
41903     thunk64_vkSetDebugUtilsObjectTagEXT,
41904     thunk64_vkSetDeviceMemoryPriorityEXT,
41905     thunk64_vkSetEvent,
41906     thunk64_vkSetHdrMetadataEXT,
41907     thunk64_vkSetPrivateData,
41908     thunk64_vkSetPrivateDataEXT,
41909     thunk64_vkSignalSemaphore,
41910     thunk64_vkSignalSemaphoreKHR,
41911     thunk64_vkSubmitDebugUtilsMessageEXT,
41912     thunk64_vkTrimCommandPool,
41913     thunk64_vkTrimCommandPoolKHR,
41914     thunk64_vkUninitializePerformanceApiINTEL,
41915     thunk64_vkUnmapMemory,
41916     thunk64_vkUnmapMemory2KHR,
41917     (void *)thunk64_vkUpdateDescriptorSetWithTemplate,
41918     thunk64_vkUpdateDescriptorSetWithTemplateKHR,
41919     (void *)thunk64_vkUpdateDescriptorSets,
41920     thunk64_vkWaitForFences,
41921     thunk64_vkWaitForPresentKHR,
41922     thunk64_vkWaitSemaphores,
41923     thunk64_vkWaitSemaphoresKHR,
41924     thunk64_vkWriteAccelerationStructuresPropertiesKHR,
41925     thunk64_vkWriteMicromapsPropertiesEXT,
41926 };
41927 C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);
41928
41929 #endif /* _WIN64 */
41930
41931 #ifdef _WIN64
41932 const unixlib_entry_t __wine_unix_call_wow64_funcs[] =
41933 #else
41934 const unixlib_entry_t __wine_unix_call_funcs[] =
41935 #endif
41936 {
41937     init_vulkan,
41938     vk_is_available_instance_function32,
41939     vk_is_available_device_function32,
41940     thunk32_vkAcquireNextImage2KHR,
41941     thunk32_vkAcquireNextImageKHR,
41942     thunk32_vkAcquirePerformanceConfigurationINTEL,
41943     thunk32_vkAcquireProfilingLockKHR,
41944     thunk32_vkAllocateCommandBuffers,
41945     thunk32_vkAllocateDescriptorSets,
41946     thunk32_vkAllocateMemory,
41947     thunk32_vkBeginCommandBuffer,
41948     thunk32_vkBindAccelerationStructureMemoryNV,
41949     thunk32_vkBindBufferMemory,
41950     thunk32_vkBindBufferMemory2,
41951     thunk32_vkBindBufferMemory2KHR,
41952     thunk32_vkBindImageMemory,
41953     thunk32_vkBindImageMemory2,
41954     thunk32_vkBindImageMemory2KHR,
41955     thunk32_vkBindOpticalFlowSessionImageNV,
41956     thunk32_vkBuildAccelerationStructuresKHR,
41957     thunk32_vkBuildMicromapsEXT,
41958     (void *)thunk32_vkCmdBeginConditionalRenderingEXT,
41959     (void *)thunk32_vkCmdBeginDebugUtilsLabelEXT,
41960     (void *)thunk32_vkCmdBeginQuery,
41961     (void *)thunk32_vkCmdBeginQueryIndexedEXT,
41962     (void *)thunk32_vkCmdBeginRenderPass,
41963     (void *)thunk32_vkCmdBeginRenderPass2,
41964     (void *)thunk32_vkCmdBeginRenderPass2KHR,
41965     (void *)thunk32_vkCmdBeginRendering,
41966     (void *)thunk32_vkCmdBeginRenderingKHR,
41967     (void *)thunk32_vkCmdBeginTransformFeedbackEXT,
41968     (void *)thunk32_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,
41969     (void *)thunk32_vkCmdBindDescriptorBuffersEXT,
41970     (void *)thunk32_vkCmdBindDescriptorSets,
41971     (void *)thunk32_vkCmdBindIndexBuffer,
41972     (void *)thunk32_vkCmdBindInvocationMaskHUAWEI,
41973     (void *)thunk32_vkCmdBindPipeline,
41974     (void *)thunk32_vkCmdBindPipelineShaderGroupNV,
41975     (void *)thunk32_vkCmdBindShadersEXT,
41976     (void *)thunk32_vkCmdBindShadingRateImageNV,
41977     (void *)thunk32_vkCmdBindTransformFeedbackBuffersEXT,
41978     (void *)thunk32_vkCmdBindVertexBuffers,
41979     (void *)thunk32_vkCmdBindVertexBuffers2,
41980     (void *)thunk32_vkCmdBindVertexBuffers2EXT,
41981     (void *)thunk32_vkCmdBlitImage,
41982     (void *)thunk32_vkCmdBlitImage2,
41983     (void *)thunk32_vkCmdBlitImage2KHR,
41984     (void *)thunk32_vkCmdBuildAccelerationStructureNV,
41985     (void *)thunk32_vkCmdBuildAccelerationStructuresIndirectKHR,
41986     (void *)thunk32_vkCmdBuildAccelerationStructuresKHR,
41987     (void *)thunk32_vkCmdBuildMicromapsEXT,
41988     (void *)thunk32_vkCmdClearAttachments,
41989     (void *)thunk32_vkCmdClearColorImage,
41990     (void *)thunk32_vkCmdClearDepthStencilImage,
41991     (void *)thunk32_vkCmdCopyAccelerationStructureKHR,
41992     (void *)thunk32_vkCmdCopyAccelerationStructureNV,
41993     (void *)thunk32_vkCmdCopyAccelerationStructureToMemoryKHR,
41994     (void *)thunk32_vkCmdCopyBuffer,
41995     (void *)thunk32_vkCmdCopyBuffer2,
41996     (void *)thunk32_vkCmdCopyBuffer2KHR,
41997     (void *)thunk32_vkCmdCopyBufferToImage,
41998     (void *)thunk32_vkCmdCopyBufferToImage2,
41999     (void *)thunk32_vkCmdCopyBufferToImage2KHR,
42000     (void *)thunk32_vkCmdCopyImage,
42001     (void *)thunk32_vkCmdCopyImage2,
42002     (void *)thunk32_vkCmdCopyImage2KHR,
42003     (void *)thunk32_vkCmdCopyImageToBuffer,
42004     (void *)thunk32_vkCmdCopyImageToBuffer2,
42005     (void *)thunk32_vkCmdCopyImageToBuffer2KHR,
42006     (void *)thunk32_vkCmdCopyMemoryIndirectNV,
42007     (void *)thunk32_vkCmdCopyMemoryToAccelerationStructureKHR,
42008     (void *)thunk32_vkCmdCopyMemoryToImageIndirectNV,
42009     (void *)thunk32_vkCmdCopyMemoryToMicromapEXT,
42010     (void *)thunk32_vkCmdCopyMicromapEXT,
42011     (void *)thunk32_vkCmdCopyMicromapToMemoryEXT,
42012     (void *)thunk32_vkCmdCopyQueryPoolResults,
42013     (void *)thunk32_vkCmdCuLaunchKernelNVX,
42014     (void *)thunk32_vkCmdDebugMarkerBeginEXT,
42015     (void *)thunk32_vkCmdDebugMarkerEndEXT,
42016     (void *)thunk32_vkCmdDebugMarkerInsertEXT,
42017     (void *)thunk32_vkCmdDecompressMemoryIndirectCountNV,
42018     (void *)thunk32_vkCmdDecompressMemoryNV,
42019     (void *)thunk32_vkCmdDispatch,
42020     (void *)thunk32_vkCmdDispatchBase,
42021     (void *)thunk32_vkCmdDispatchBaseKHR,
42022     (void *)thunk32_vkCmdDispatchIndirect,
42023     (void *)thunk32_vkCmdDraw,
42024     (void *)thunk32_vkCmdDrawClusterHUAWEI,
42025     (void *)thunk32_vkCmdDrawClusterIndirectHUAWEI,
42026     (void *)thunk32_vkCmdDrawIndexed,
42027     (void *)thunk32_vkCmdDrawIndexedIndirect,
42028     (void *)thunk32_vkCmdDrawIndexedIndirectCount,
42029     (void *)thunk32_vkCmdDrawIndexedIndirectCountAMD,
42030     (void *)thunk32_vkCmdDrawIndexedIndirectCountKHR,
42031     (void *)thunk32_vkCmdDrawIndirect,
42032     (void *)thunk32_vkCmdDrawIndirectByteCountEXT,
42033     (void *)thunk32_vkCmdDrawIndirectCount,
42034     (void *)thunk32_vkCmdDrawIndirectCountAMD,
42035     (void *)thunk32_vkCmdDrawIndirectCountKHR,
42036     (void *)thunk32_vkCmdDrawMeshTasksEXT,
42037     (void *)thunk32_vkCmdDrawMeshTasksIndirectCountEXT,
42038     (void *)thunk32_vkCmdDrawMeshTasksIndirectCountNV,
42039     (void *)thunk32_vkCmdDrawMeshTasksIndirectEXT,
42040     (void *)thunk32_vkCmdDrawMeshTasksIndirectNV,
42041     (void *)thunk32_vkCmdDrawMeshTasksNV,
42042     (void *)thunk32_vkCmdDrawMultiEXT,
42043     (void *)thunk32_vkCmdDrawMultiIndexedEXT,
42044     (void *)thunk32_vkCmdEndConditionalRenderingEXT,
42045     (void *)thunk32_vkCmdEndDebugUtilsLabelEXT,
42046     (void *)thunk32_vkCmdEndQuery,
42047     (void *)thunk32_vkCmdEndQueryIndexedEXT,
42048     (void *)thunk32_vkCmdEndRenderPass,
42049     (void *)thunk32_vkCmdEndRenderPass2,
42050     (void *)thunk32_vkCmdEndRenderPass2KHR,
42051     (void *)thunk32_vkCmdEndRendering,
42052     (void *)thunk32_vkCmdEndRenderingKHR,
42053     (void *)thunk32_vkCmdEndTransformFeedbackEXT,
42054     (void *)thunk32_vkCmdExecuteCommands,
42055     (void *)thunk32_vkCmdExecuteGeneratedCommandsNV,
42056     (void *)thunk32_vkCmdFillBuffer,
42057     (void *)thunk32_vkCmdInsertDebugUtilsLabelEXT,
42058     (void *)thunk32_vkCmdNextSubpass,
42059     (void *)thunk32_vkCmdNextSubpass2,
42060     (void *)thunk32_vkCmdNextSubpass2KHR,
42061     (void *)thunk32_vkCmdOpticalFlowExecuteNV,
42062     (void *)thunk32_vkCmdPipelineBarrier,
42063     (void *)thunk32_vkCmdPipelineBarrier2,
42064     (void *)thunk32_vkCmdPipelineBarrier2KHR,
42065     (void *)thunk32_vkCmdPreprocessGeneratedCommandsNV,
42066     (void *)thunk32_vkCmdPushConstants,
42067     (void *)thunk32_vkCmdPushDescriptorSetKHR,
42068     (void *)thunk32_vkCmdPushDescriptorSetWithTemplateKHR,
42069     (void *)thunk32_vkCmdResetEvent,
42070     (void *)thunk32_vkCmdResetEvent2,
42071     (void *)thunk32_vkCmdResetEvent2KHR,
42072     (void *)thunk32_vkCmdResetQueryPool,
42073     (void *)thunk32_vkCmdResolveImage,
42074     (void *)thunk32_vkCmdResolveImage2,
42075     (void *)thunk32_vkCmdResolveImage2KHR,
42076     (void *)thunk32_vkCmdSetAlphaToCoverageEnableEXT,
42077     (void *)thunk32_vkCmdSetAlphaToOneEnableEXT,
42078     (void *)thunk32_vkCmdSetAttachmentFeedbackLoopEnableEXT,
42079     (void *)thunk32_vkCmdSetBlendConstants,
42080     (void *)thunk32_vkCmdSetCheckpointNV,
42081     (void *)thunk32_vkCmdSetCoarseSampleOrderNV,
42082     (void *)thunk32_vkCmdSetColorBlendAdvancedEXT,
42083     (void *)thunk32_vkCmdSetColorBlendEnableEXT,
42084     (void *)thunk32_vkCmdSetColorBlendEquationEXT,
42085     (void *)thunk32_vkCmdSetColorWriteEnableEXT,
42086     (void *)thunk32_vkCmdSetColorWriteMaskEXT,
42087     (void *)thunk32_vkCmdSetConservativeRasterizationModeEXT,
42088     (void *)thunk32_vkCmdSetCoverageModulationModeNV,
42089     (void *)thunk32_vkCmdSetCoverageModulationTableEnableNV,
42090     (void *)thunk32_vkCmdSetCoverageModulationTableNV,
42091     (void *)thunk32_vkCmdSetCoverageReductionModeNV,
42092     (void *)thunk32_vkCmdSetCoverageToColorEnableNV,
42093     (void *)thunk32_vkCmdSetCoverageToColorLocationNV,
42094     (void *)thunk32_vkCmdSetCullMode,
42095     (void *)thunk32_vkCmdSetCullModeEXT,
42096     (void *)thunk32_vkCmdSetDepthBias,
42097     (void *)thunk32_vkCmdSetDepthBiasEnable,
42098     (void *)thunk32_vkCmdSetDepthBiasEnableEXT,
42099     (void *)thunk32_vkCmdSetDepthBounds,
42100     (void *)thunk32_vkCmdSetDepthBoundsTestEnable,
42101     (void *)thunk32_vkCmdSetDepthBoundsTestEnableEXT,
42102     (void *)thunk32_vkCmdSetDepthClampEnableEXT,
42103     (void *)thunk32_vkCmdSetDepthClipEnableEXT,
42104     (void *)thunk32_vkCmdSetDepthClipNegativeOneToOneEXT,
42105     (void *)thunk32_vkCmdSetDepthCompareOp,
42106     (void *)thunk32_vkCmdSetDepthCompareOpEXT,
42107     (void *)thunk32_vkCmdSetDepthTestEnable,
42108     (void *)thunk32_vkCmdSetDepthTestEnableEXT,
42109     (void *)thunk32_vkCmdSetDepthWriteEnable,
42110     (void *)thunk32_vkCmdSetDepthWriteEnableEXT,
42111     (void *)thunk32_vkCmdSetDescriptorBufferOffsetsEXT,
42112     (void *)thunk32_vkCmdSetDeviceMask,
42113     (void *)thunk32_vkCmdSetDeviceMaskKHR,
42114     (void *)thunk32_vkCmdSetDiscardRectangleEXT,
42115     (void *)thunk32_vkCmdSetDiscardRectangleEnableEXT,
42116     (void *)thunk32_vkCmdSetDiscardRectangleModeEXT,
42117     (void *)thunk32_vkCmdSetEvent,
42118     (void *)thunk32_vkCmdSetEvent2,
42119     (void *)thunk32_vkCmdSetEvent2KHR,
42120     (void *)thunk32_vkCmdSetExclusiveScissorEnableNV,
42121     (void *)thunk32_vkCmdSetExclusiveScissorNV,
42122     (void *)thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
42123     (void *)thunk32_vkCmdSetFragmentShadingRateEnumNV,
42124     (void *)thunk32_vkCmdSetFragmentShadingRateKHR,
42125     (void *)thunk32_vkCmdSetFrontFace,
42126     (void *)thunk32_vkCmdSetFrontFaceEXT,
42127     (void *)thunk32_vkCmdSetLineRasterizationModeEXT,
42128     (void *)thunk32_vkCmdSetLineStippleEXT,
42129     (void *)thunk32_vkCmdSetLineStippleEnableEXT,
42130     (void *)thunk32_vkCmdSetLineWidth,
42131     (void *)thunk32_vkCmdSetLogicOpEXT,
42132     (void *)thunk32_vkCmdSetLogicOpEnableEXT,
42133     (void *)thunk32_vkCmdSetPatchControlPointsEXT,
42134     thunk32_vkCmdSetPerformanceMarkerINTEL,
42135     thunk32_vkCmdSetPerformanceOverrideINTEL,
42136     thunk32_vkCmdSetPerformanceStreamMarkerINTEL,
42137     (void *)thunk32_vkCmdSetPolygonModeEXT,
42138     (void *)thunk32_vkCmdSetPrimitiveRestartEnable,
42139     (void *)thunk32_vkCmdSetPrimitiveRestartEnableEXT,
42140     (void *)thunk32_vkCmdSetPrimitiveTopology,
42141     (void *)thunk32_vkCmdSetPrimitiveTopologyEXT,
42142     (void *)thunk32_vkCmdSetProvokingVertexModeEXT,
42143     (void *)thunk32_vkCmdSetRasterizationSamplesEXT,
42144     (void *)thunk32_vkCmdSetRasterizationStreamEXT,
42145     (void *)thunk32_vkCmdSetRasterizerDiscardEnable,
42146     (void *)thunk32_vkCmdSetRasterizerDiscardEnableEXT,
42147     (void *)thunk32_vkCmdSetRayTracingPipelineStackSizeKHR,
42148     (void *)thunk32_vkCmdSetRepresentativeFragmentTestEnableNV,
42149     (void *)thunk32_vkCmdSetSampleLocationsEXT,
42150     (void *)thunk32_vkCmdSetSampleLocationsEnableEXT,
42151     (void *)thunk32_vkCmdSetSampleMaskEXT,
42152     (void *)thunk32_vkCmdSetScissor,
42153     (void *)thunk32_vkCmdSetScissorWithCount,
42154     (void *)thunk32_vkCmdSetScissorWithCountEXT,
42155     (void *)thunk32_vkCmdSetShadingRateImageEnableNV,
42156     (void *)thunk32_vkCmdSetStencilCompareMask,
42157     (void *)thunk32_vkCmdSetStencilOp,
42158     (void *)thunk32_vkCmdSetStencilOpEXT,
42159     (void *)thunk32_vkCmdSetStencilReference,
42160     (void *)thunk32_vkCmdSetStencilTestEnable,
42161     (void *)thunk32_vkCmdSetStencilTestEnableEXT,
42162     (void *)thunk32_vkCmdSetStencilWriteMask,
42163     (void *)thunk32_vkCmdSetTessellationDomainOriginEXT,
42164     (void *)thunk32_vkCmdSetVertexInputEXT,
42165     (void *)thunk32_vkCmdSetViewport,
42166     (void *)thunk32_vkCmdSetViewportShadingRatePaletteNV,
42167     (void *)thunk32_vkCmdSetViewportSwizzleNV,
42168     (void *)thunk32_vkCmdSetViewportWScalingEnableNV,
42169     (void *)thunk32_vkCmdSetViewportWScalingNV,
42170     (void *)thunk32_vkCmdSetViewportWithCount,
42171     (void *)thunk32_vkCmdSetViewportWithCountEXT,
42172     (void *)thunk32_vkCmdSubpassShadingHUAWEI,
42173     (void *)thunk32_vkCmdTraceRaysIndirect2KHR,
42174     (void *)thunk32_vkCmdTraceRaysIndirectKHR,
42175     (void *)thunk32_vkCmdTraceRaysKHR,
42176     (void *)thunk32_vkCmdTraceRaysNV,
42177     (void *)thunk32_vkCmdUpdateBuffer,
42178     (void *)thunk32_vkCmdWaitEvents,
42179     (void *)thunk32_vkCmdWaitEvents2,
42180     (void *)thunk32_vkCmdWaitEvents2KHR,
42181     (void *)thunk32_vkCmdWriteAccelerationStructuresPropertiesKHR,
42182     (void *)thunk32_vkCmdWriteAccelerationStructuresPropertiesNV,
42183     (void *)thunk32_vkCmdWriteBufferMarker2AMD,
42184     (void *)thunk32_vkCmdWriteBufferMarkerAMD,
42185     (void *)thunk32_vkCmdWriteMicromapsPropertiesEXT,
42186     (void *)thunk32_vkCmdWriteTimestamp,
42187     (void *)thunk32_vkCmdWriteTimestamp2,
42188     (void *)thunk32_vkCmdWriteTimestamp2KHR,
42189     thunk32_vkCompileDeferredNV,
42190     thunk32_vkCopyAccelerationStructureKHR,
42191     thunk32_vkCopyAccelerationStructureToMemoryKHR,
42192     thunk32_vkCopyMemoryToAccelerationStructureKHR,
42193     thunk32_vkCopyMemoryToMicromapEXT,
42194     thunk32_vkCopyMicromapEXT,
42195     thunk32_vkCopyMicromapToMemoryEXT,
42196     thunk32_vkCreateAccelerationStructureKHR,
42197     thunk32_vkCreateAccelerationStructureNV,
42198     thunk32_vkCreateBuffer,
42199     thunk32_vkCreateBufferView,
42200     thunk32_vkCreateCommandPool,
42201     thunk32_vkCreateComputePipelines,
42202     thunk32_vkCreateCuFunctionNVX,
42203     thunk32_vkCreateCuModuleNVX,
42204     thunk32_vkCreateDebugReportCallbackEXT,
42205     thunk32_vkCreateDebugUtilsMessengerEXT,
42206     thunk32_vkCreateDeferredOperationKHR,
42207     thunk32_vkCreateDescriptorPool,
42208     thunk32_vkCreateDescriptorSetLayout,
42209     thunk32_vkCreateDescriptorUpdateTemplate,
42210     thunk32_vkCreateDescriptorUpdateTemplateKHR,
42211     thunk32_vkCreateDevice,
42212     thunk32_vkCreateEvent,
42213     thunk32_vkCreateFence,
42214     thunk32_vkCreateFramebuffer,
42215     thunk32_vkCreateGraphicsPipelines,
42216     thunk32_vkCreateImage,
42217     thunk32_vkCreateImageView,
42218     thunk32_vkCreateIndirectCommandsLayoutNV,
42219     thunk32_vkCreateInstance,
42220     thunk32_vkCreateMicromapEXT,
42221     thunk32_vkCreateOpticalFlowSessionNV,
42222     thunk32_vkCreatePipelineCache,
42223     thunk32_vkCreatePipelineLayout,
42224     thunk32_vkCreatePrivateDataSlot,
42225     thunk32_vkCreatePrivateDataSlotEXT,
42226     thunk32_vkCreateQueryPool,
42227     thunk32_vkCreateRayTracingPipelinesKHR,
42228     thunk32_vkCreateRayTracingPipelinesNV,
42229     thunk32_vkCreateRenderPass,
42230     thunk32_vkCreateRenderPass2,
42231     thunk32_vkCreateRenderPass2KHR,
42232     thunk32_vkCreateSampler,
42233     thunk32_vkCreateSamplerYcbcrConversion,
42234     thunk32_vkCreateSamplerYcbcrConversionKHR,
42235     thunk32_vkCreateSemaphore,
42236     thunk32_vkCreateShaderModule,
42237     thunk32_vkCreateShadersEXT,
42238     thunk32_vkCreateSwapchainKHR,
42239     thunk32_vkCreateValidationCacheEXT,
42240     thunk32_vkCreateWin32SurfaceKHR,
42241     thunk32_vkDebugMarkerSetObjectNameEXT,
42242     thunk32_vkDebugMarkerSetObjectTagEXT,
42243     thunk32_vkDebugReportMessageEXT,
42244     thunk32_vkDeferredOperationJoinKHR,
42245     thunk32_vkDestroyAccelerationStructureKHR,
42246     thunk32_vkDestroyAccelerationStructureNV,
42247     thunk32_vkDestroyBuffer,
42248     thunk32_vkDestroyBufferView,
42249     thunk32_vkDestroyCommandPool,
42250     thunk32_vkDestroyCuFunctionNVX,
42251     thunk32_vkDestroyCuModuleNVX,
42252     thunk32_vkDestroyDebugReportCallbackEXT,
42253     thunk32_vkDestroyDebugUtilsMessengerEXT,
42254     thunk32_vkDestroyDeferredOperationKHR,
42255     thunk32_vkDestroyDescriptorPool,
42256     thunk32_vkDestroyDescriptorSetLayout,
42257     thunk32_vkDestroyDescriptorUpdateTemplate,
42258     thunk32_vkDestroyDescriptorUpdateTemplateKHR,
42259     thunk32_vkDestroyDevice,
42260     thunk32_vkDestroyEvent,
42261     thunk32_vkDestroyFence,
42262     thunk32_vkDestroyFramebuffer,
42263     thunk32_vkDestroyImage,
42264     thunk32_vkDestroyImageView,
42265     thunk32_vkDestroyIndirectCommandsLayoutNV,
42266     thunk32_vkDestroyInstance,
42267     thunk32_vkDestroyMicromapEXT,
42268     thunk32_vkDestroyOpticalFlowSessionNV,
42269     thunk32_vkDestroyPipeline,
42270     thunk32_vkDestroyPipelineCache,
42271     thunk32_vkDestroyPipelineLayout,
42272     thunk32_vkDestroyPrivateDataSlot,
42273     thunk32_vkDestroyPrivateDataSlotEXT,
42274     thunk32_vkDestroyQueryPool,
42275     thunk32_vkDestroyRenderPass,
42276     thunk32_vkDestroySampler,
42277     thunk32_vkDestroySamplerYcbcrConversion,
42278     thunk32_vkDestroySamplerYcbcrConversionKHR,
42279     thunk32_vkDestroySemaphore,
42280     thunk32_vkDestroyShaderEXT,
42281     thunk32_vkDestroyShaderModule,
42282     thunk32_vkDestroySurfaceKHR,
42283     thunk32_vkDestroySwapchainKHR,
42284     thunk32_vkDestroyValidationCacheEXT,
42285     thunk32_vkDeviceWaitIdle,
42286     thunk32_vkEndCommandBuffer,
42287     thunk32_vkEnumerateDeviceExtensionProperties,
42288     thunk32_vkEnumerateDeviceLayerProperties,
42289     thunk32_vkEnumerateInstanceExtensionProperties,
42290     thunk32_vkEnumerateInstanceVersion,
42291     thunk32_vkEnumeratePhysicalDeviceGroups,
42292     thunk32_vkEnumeratePhysicalDeviceGroupsKHR,
42293     thunk32_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
42294     thunk32_vkEnumeratePhysicalDevices,
42295     thunk32_vkFlushMappedMemoryRanges,
42296     thunk32_vkFreeCommandBuffers,
42297     thunk32_vkFreeDescriptorSets,
42298     thunk32_vkFreeMemory,
42299     thunk32_vkGetAccelerationStructureBuildSizesKHR,
42300     thunk32_vkGetAccelerationStructureDeviceAddressKHR,
42301     thunk32_vkGetAccelerationStructureHandleNV,
42302     thunk32_vkGetAccelerationStructureMemoryRequirementsNV,
42303     thunk32_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT,
42304     thunk32_vkGetBufferDeviceAddress,
42305     thunk32_vkGetBufferDeviceAddressEXT,
42306     thunk32_vkGetBufferDeviceAddressKHR,
42307     thunk32_vkGetBufferMemoryRequirements,
42308     thunk32_vkGetBufferMemoryRequirements2,
42309     thunk32_vkGetBufferMemoryRequirements2KHR,
42310     thunk32_vkGetBufferOpaqueCaptureAddress,
42311     thunk32_vkGetBufferOpaqueCaptureAddressKHR,
42312     thunk32_vkGetBufferOpaqueCaptureDescriptorDataEXT,
42313     thunk32_vkGetCalibratedTimestampsEXT,
42314     thunk32_vkGetDeferredOperationMaxConcurrencyKHR,
42315     thunk32_vkGetDeferredOperationResultKHR,
42316     (void *)thunk32_vkGetDescriptorEXT,
42317     thunk32_vkGetDescriptorSetHostMappingVALVE,
42318     thunk32_vkGetDescriptorSetLayoutBindingOffsetEXT,
42319     thunk32_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
42320     thunk32_vkGetDescriptorSetLayoutSizeEXT,
42321     thunk32_vkGetDescriptorSetLayoutSupport,
42322     thunk32_vkGetDescriptorSetLayoutSupportKHR,
42323     thunk32_vkGetDeviceAccelerationStructureCompatibilityKHR,
42324     thunk32_vkGetDeviceBufferMemoryRequirements,
42325     thunk32_vkGetDeviceBufferMemoryRequirementsKHR,
42326     thunk32_vkGetDeviceFaultInfoEXT,
42327     thunk32_vkGetDeviceGroupPeerMemoryFeatures,
42328     thunk32_vkGetDeviceGroupPeerMemoryFeaturesKHR,
42329     thunk32_vkGetDeviceGroupPresentCapabilitiesKHR,
42330     thunk32_vkGetDeviceGroupSurfacePresentModesKHR,
42331     thunk32_vkGetDeviceImageMemoryRequirements,
42332     thunk32_vkGetDeviceImageMemoryRequirementsKHR,
42333     thunk32_vkGetDeviceImageSparseMemoryRequirements,
42334     thunk32_vkGetDeviceImageSparseMemoryRequirementsKHR,
42335     thunk32_vkGetDeviceMemoryCommitment,
42336     thunk32_vkGetDeviceMemoryOpaqueCaptureAddress,
42337     thunk32_vkGetDeviceMemoryOpaqueCaptureAddressKHR,
42338     thunk32_vkGetDeviceMicromapCompatibilityEXT,
42339     thunk32_vkGetDeviceQueue,
42340     thunk32_vkGetDeviceQueue2,
42341     thunk32_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
42342     thunk32_vkGetDynamicRenderingTilePropertiesQCOM,
42343     thunk32_vkGetEventStatus,
42344     thunk32_vkGetFenceStatus,
42345     thunk32_vkGetFramebufferTilePropertiesQCOM,
42346     thunk32_vkGetGeneratedCommandsMemoryRequirementsNV,
42347     thunk32_vkGetImageMemoryRequirements,
42348     thunk32_vkGetImageMemoryRequirements2,
42349     thunk32_vkGetImageMemoryRequirements2KHR,
42350     thunk32_vkGetImageOpaqueCaptureDescriptorDataEXT,
42351     thunk32_vkGetImageSparseMemoryRequirements,
42352     thunk32_vkGetImageSparseMemoryRequirements2,
42353     thunk32_vkGetImageSparseMemoryRequirements2KHR,
42354     thunk32_vkGetImageSubresourceLayout,
42355     thunk32_vkGetImageSubresourceLayout2EXT,
42356     thunk32_vkGetImageViewAddressNVX,
42357     thunk32_vkGetImageViewHandleNVX,
42358     thunk32_vkGetImageViewOpaqueCaptureDescriptorDataEXT,
42359     thunk32_vkGetMemoryHostPointerPropertiesEXT,
42360     thunk32_vkGetMicromapBuildSizesEXT,
42361     thunk32_vkGetPerformanceParameterINTEL,
42362     thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
42363     thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
42364     thunk32_vkGetPhysicalDeviceExternalBufferProperties,
42365     thunk32_vkGetPhysicalDeviceExternalBufferPropertiesKHR,
42366     thunk32_vkGetPhysicalDeviceExternalFenceProperties,
42367     thunk32_vkGetPhysicalDeviceExternalFencePropertiesKHR,
42368     thunk32_vkGetPhysicalDeviceExternalSemaphoreProperties,
42369     thunk32_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,
42370     thunk32_vkGetPhysicalDeviceFeatures,
42371     thunk32_vkGetPhysicalDeviceFeatures2,
42372     thunk32_vkGetPhysicalDeviceFeatures2KHR,
42373     thunk32_vkGetPhysicalDeviceFormatProperties,
42374     thunk32_vkGetPhysicalDeviceFormatProperties2,
42375     thunk32_vkGetPhysicalDeviceFormatProperties2KHR,
42376     thunk32_vkGetPhysicalDeviceFragmentShadingRatesKHR,
42377     thunk32_vkGetPhysicalDeviceImageFormatProperties,
42378     thunk32_vkGetPhysicalDeviceImageFormatProperties2,
42379     thunk32_vkGetPhysicalDeviceImageFormatProperties2KHR,
42380     thunk32_vkGetPhysicalDeviceMemoryProperties,
42381     thunk32_vkGetPhysicalDeviceMemoryProperties2,
42382     thunk32_vkGetPhysicalDeviceMemoryProperties2KHR,
42383     thunk32_vkGetPhysicalDeviceMultisamplePropertiesEXT,
42384     thunk32_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
42385     thunk32_vkGetPhysicalDevicePresentRectanglesKHR,
42386     thunk32_vkGetPhysicalDeviceProperties,
42387     thunk32_vkGetPhysicalDeviceProperties2,
42388     thunk32_vkGetPhysicalDeviceProperties2KHR,
42389     thunk32_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
42390     thunk32_vkGetPhysicalDeviceQueueFamilyProperties,
42391     thunk32_vkGetPhysicalDeviceQueueFamilyProperties2,
42392     thunk32_vkGetPhysicalDeviceQueueFamilyProperties2KHR,
42393     thunk32_vkGetPhysicalDeviceSparseImageFormatProperties,
42394     thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2,
42395     thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,
42396     thunk32_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
42397     thunk32_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
42398     thunk32_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
42399     thunk32_vkGetPhysicalDeviceSurfaceFormats2KHR,
42400     thunk32_vkGetPhysicalDeviceSurfaceFormatsKHR,
42401     thunk32_vkGetPhysicalDeviceSurfacePresentModesKHR,
42402     thunk32_vkGetPhysicalDeviceSurfaceSupportKHR,
42403     thunk32_vkGetPhysicalDeviceToolProperties,
42404     thunk32_vkGetPhysicalDeviceToolPropertiesEXT,
42405     thunk32_vkGetPhysicalDeviceWin32PresentationSupportKHR,
42406     thunk32_vkGetPipelineCacheData,
42407     thunk32_vkGetPipelineExecutableInternalRepresentationsKHR,
42408     thunk32_vkGetPipelineExecutablePropertiesKHR,
42409     thunk32_vkGetPipelineExecutableStatisticsKHR,
42410     thunk32_vkGetPipelinePropertiesEXT,
42411     thunk32_vkGetPrivateData,
42412     thunk32_vkGetPrivateDataEXT,
42413     thunk32_vkGetQueryPoolResults,
42414     thunk32_vkGetQueueCheckpointData2NV,
42415     thunk32_vkGetQueueCheckpointDataNV,
42416     thunk32_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
42417     thunk32_vkGetRayTracingShaderGroupHandlesKHR,
42418     thunk32_vkGetRayTracingShaderGroupHandlesNV,
42419     thunk32_vkGetRayTracingShaderGroupStackSizeKHR,
42420     thunk32_vkGetRenderAreaGranularity,
42421     thunk32_vkGetSamplerOpaqueCaptureDescriptorDataEXT,
42422     thunk32_vkGetSemaphoreCounterValue,
42423     thunk32_vkGetSemaphoreCounterValueKHR,
42424     thunk32_vkGetShaderBinaryDataEXT,
42425     thunk32_vkGetShaderInfoAMD,
42426     thunk32_vkGetShaderModuleCreateInfoIdentifierEXT,
42427     thunk32_vkGetShaderModuleIdentifierEXT,
42428     thunk32_vkGetSwapchainImagesKHR,
42429     thunk32_vkGetValidationCacheDataEXT,
42430     thunk32_vkInitializePerformanceApiINTEL,
42431     thunk32_vkInvalidateMappedMemoryRanges,
42432     thunk32_vkMapMemory,
42433     thunk32_vkMapMemory2KHR,
42434     thunk32_vkMergePipelineCaches,
42435     thunk32_vkMergeValidationCachesEXT,
42436     thunk32_vkQueueBeginDebugUtilsLabelEXT,
42437     thunk32_vkQueueBindSparse,
42438     thunk32_vkQueueEndDebugUtilsLabelEXT,
42439     thunk32_vkQueueInsertDebugUtilsLabelEXT,
42440     thunk32_vkQueuePresentKHR,
42441     thunk32_vkQueueSetPerformanceConfigurationINTEL,
42442     thunk32_vkQueueSubmit,
42443     thunk32_vkQueueSubmit2,
42444     thunk32_vkQueueSubmit2KHR,
42445     thunk32_vkQueueWaitIdle,
42446     thunk32_vkReleasePerformanceConfigurationINTEL,
42447     thunk32_vkReleaseProfilingLockKHR,
42448     thunk32_vkReleaseSwapchainImagesEXT,
42449     thunk32_vkResetCommandBuffer,
42450     thunk32_vkResetCommandPool,
42451     thunk32_vkResetDescriptorPool,
42452     thunk32_vkResetEvent,
42453     thunk32_vkResetFences,
42454     thunk32_vkResetQueryPool,
42455     thunk32_vkResetQueryPoolEXT,
42456     thunk32_vkSetDebugUtilsObjectNameEXT,
42457     thunk32_vkSetDebugUtilsObjectTagEXT,
42458     thunk32_vkSetDeviceMemoryPriorityEXT,
42459     thunk32_vkSetEvent,
42460     thunk32_vkSetHdrMetadataEXT,
42461     thunk32_vkSetPrivateData,
42462     thunk32_vkSetPrivateDataEXT,
42463     thunk32_vkSignalSemaphore,
42464     thunk32_vkSignalSemaphoreKHR,
42465     thunk32_vkSubmitDebugUtilsMessageEXT,
42466     thunk32_vkTrimCommandPool,
42467     thunk32_vkTrimCommandPoolKHR,
42468     thunk32_vkUninitializePerformanceApiINTEL,
42469     thunk32_vkUnmapMemory,
42470     thunk32_vkUnmapMemory2KHR,
42471     (void *)thunk32_vkUpdateDescriptorSetWithTemplate,
42472     thunk32_vkUpdateDescriptorSetWithTemplateKHR,
42473     (void *)thunk32_vkUpdateDescriptorSets,
42474     thunk32_vkWaitForFences,
42475     thunk32_vkWaitForPresentKHR,
42476     thunk32_vkWaitSemaphores,
42477     thunk32_vkWaitSemaphoresKHR,
42478     thunk32_vkWriteAccelerationStructuresPropertiesKHR,
42479     thunk32_vkWriteMicromapsPropertiesEXT,
42480 };
42481 C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);